{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# **任务描述：**\n",
    "\n",
    "### 本次实践是一个多分类任务，需要将照片中的每个字符分别进行识别，完成**车牌的识别**\n",
    "\n",
    "### **实践平台：百度AI实训平台-AI Studio、PaddlePaddle1.8.0 动态图**\n",
    "\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/4937002eccc64274b9877ad4c961fe32fff0a6b3e32e468390ba68d29664c6c4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 深度神经网络(DNN)\n",
    "\n",
    "### **深度神经网络（Deep Neural Networks，简称DNN）是深度学习的基础，其结构为input、hidden（可有多层）、output，每层均为全连接。**\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/c60fc28848cf469fa3a7824aa637a03f3b2b213ce7b84659919cb24b4430bffb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 数据集介绍\n",
    "\n",
    "* **数据集文件名为characterData.zip，其中有65个文件夹**\n",
    "\n",
    "* **包含0-9，A-Z，以及各省简称**\n",
    "\n",
    "* **图片为1*20*20的灰度图像**\n",
    "\n",
    "* **本次实验中，取其中的10%作为测试集，90%作为训练集**\n",
    "\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/98752767a5da477eb5a2927d491e890cf2c82725afbd49b5826fab44e514218a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data23617\r\n"
     ]
    }
   ],
   "source": [
    "# 查看当前挂载的数据集目录, 该目录下的变更重启环境后会自动还原\n",
    "# View dataset directory. This directory will be recovered automatically after resetting environment. \n",
    "!ls /home/aistudio/data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-06-13 20:34:03,635-INFO: font search path ['/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/ttf', '/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/afm', '/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/pdfcorefonts']\n",
      "2023-06-13 20:34:04,269-INFO: generated new fontManager\n"
     ]
    }
   ],
   "source": [
    "#导入需要的包\n",
    "import os\n",
    "import zipfile\n",
    "import random\n",
    "import json\n",
    "import cv2\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "from paddle.fluid.dygraph import Linear,Conv2D,Pool2D\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 1、数据准备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "'''\n",
    "参数配置\n",
    "'''\n",
    "train_parameters = {\n",
    "    \"input_size\": [1, 20, 20],                           #输入图片的shape\n",
    "    \"class_dim\": -1,                                     #分类数\n",
    "    \"src_path\":\"data/data23617/characterData.zip\",       #原始数据集路径\n",
    "    \"target_path\":\"/home/aistudio/data/dataset\",        #要解压的路径 \n",
    "    \"train_list_path\": \"./train_data.txt\",              #train_data.txt路径\n",
    "    \"eval_list_path\": \"./val_data.txt\",                  #eval_data.txt路径\n",
    "    \"label_dict\":{},                                    #标签字典\n",
    "    \"readme_path\": \"/home/aistudio/data/readme.json\",   #readme.json路径\n",
    "    \"num_epochs\": 1,                                    #训练轮数\n",
    "    \"train_batch_size\": 32,                             #批次的大小\n",
    "    \"learning_strategy\": {                              #优化函数相关的配置\n",
    "        \"lr\": 0.001                                     #超参数学习率\n",
    "    } \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def unzip_data(src_path,target_path):\n",
    "    '''\n",
    "    解压原始数据集，将src_path路径下的zip包解压至data/dataset目录下\n",
    "    '''\n",
    "    if(not os.path.isdir(target_path)):    \n",
    "        z = zipfile.ZipFile(src_path, 'r')\n",
    "        z.extractall(path=target_path)\n",
    "        z.close()\n",
    "    else:\n",
    "        print(\"文件已解压\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "def get_data_list(target_path,train_list_path,eval_list_path):\n",
    "    '''\n",
    "    生成数据列表\n",
    "    '''\n",
    "    #存放所有类别的信息\n",
    "    class_detail = []\n",
    "    #获取所有类别保存的文件夹名称\n",
    "    data_list_path=target_path\n",
    "    class_dirs = os.listdir(data_list_path)\n",
    "    if '__MACOSX' in class_dirs:\n",
    "        class_dirs.remove('__MACOSX')\n",
    "    # #总的图像数量\n",
    "    all_class_images = 0\n",
    "    # #存放类别标签\n",
    "    class_label=0\n",
    "    # #存放类别数目\n",
    "    class_dim = 0\n",
    "    # #存储要写进eval.txt和train.txt中的内容\n",
    "    trainer_list=[]\n",
    "    eval_list=[]\n",
    "    #读取每个类别\n",
    "    for class_dir in class_dirs:\n",
    "        if class_dir != \".DS_Store\":\n",
    "            class_dim += 1\n",
    "            #每个类别的信息\n",
    "            class_detail_list = {}\n",
    "            eval_sum = 0\n",
    "            trainer_sum = 0\n",
    "            #统计每个类别有多少张图片\n",
    "            class_sum = 0\n",
    "            #获取类别路径 \n",
    "            path = os.path.join(data_list_path,class_dir)\n",
    "            # print(path)\n",
    "            # 获取所有图片\n",
    "            img_paths = os.listdir(path)\n",
    "            for img_path in img_paths:                                  # 遍历文件夹下的每个图片\n",
    "                if img_path =='.DS_Store':\n",
    "                    continue\n",
    "                name_path = os.path.join(path,img_path)                       # 每张图片的路径\n",
    "                if class_sum % 10 == 0:                                 # 每10张图片取一个做验证数据\n",
    "                    eval_sum += 1                                       # eval_sum为测试数据的数目\n",
    "                    eval_list.append(name_path + \"\\t%d\" % class_label + \"\\n\")\n",
    "                else:\n",
    "                    trainer_sum += 1 \n",
    "                    trainer_list.append(name_path + \"\\t%d\" % class_label + \"\\n\")#trainer_sum测试数据的数目\n",
    "                class_sum += 1                                          #每类图片的数目\n",
    "                all_class_images += 1                                   #所有类图片的数目\n",
    "            \n",
    "            # 说明的json文件的class_detail数据\n",
    "            class_detail_list['class_name'] = class_dir             #类别名称\n",
    "            class_detail_list['class_label'] = class_label          #类别标签\n",
    "            class_detail_list['class_eval_images'] = eval_sum       #该类数据的测试集数目\n",
    "            class_detail_list['class_trainer_images'] = trainer_sum #该类数据的训练集数目\n",
    "            class_detail.append(class_detail_list)  \n",
    "            #初始化标签列表\n",
    "            train_parameters['label_dict'][str(class_label)] = class_dir\n",
    "            class_label += 1\n",
    "            \n",
    "    #初始化分类数\n",
    "    train_parameters['class_dim'] = class_dim\n",
    "    print(train_parameters)\n",
    "    #乱序  \n",
    "    random.shuffle(eval_list)\n",
    "    with open(eval_list_path, 'a') as f:\n",
    "        for eval_image in eval_list:\n",
    "            f.write(eval_image) \n",
    "    #乱序        \n",
    "    random.shuffle(trainer_list) \n",
    "    with open(train_list_path, 'a') as f2:\n",
    "        for train_image in trainer_list:\n",
    "            f2.write(train_image) \n",
    "\n",
    "    # 说明的json文件信息\n",
    "    readjson = {}\n",
    "    readjson['all_class_name'] = data_list_path                  #文件父目录\n",
    "    readjson['all_class_images'] = all_class_images\n",
    "    readjson['class_detail'] = class_detail\n",
    "    jsons = json.dumps(readjson, sort_keys=True, indent=4, separators=(',', ': '))\n",
    "    with open(train_parameters['readme_path'],'w') as f:\n",
    "        f.write(jsons)\n",
    "    print ('生成数据列表完成！')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def data_reader(file_list):\n",
    "    '''\n",
    "    自定义data_reader\n",
    "    '''\n",
    "    def reader():\n",
    "        with open(file_list, 'r') as f:\n",
    "            lines = [line.strip() for line in f]\n",
    "            for line in lines:\n",
    "                img_path, lab = line.strip().split('\\t')\n",
    "                img = cv2.imread(img_path)\n",
    "                img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "                img = np.array(img).astype('float32')\n",
    "                img = img/255.0\n",
    "                yield img, int(lab) \n",
    "    return reader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'input_size': [1, 20, 20], 'class_dim': 65, 'src_path': 'data/data23617/characterData.zip', 'target_path': '/home/aistudio/data/dataset', 'train_list_path': './train_data.txt', 'eval_list_path': './val_data.txt', 'label_dict': {'0': 'gan1', '1': 'P', '2': 'qing', '3': 'shan', '4': 'E', '5': 'su', '6': 'W', '7': 'R', '8': 'U', '9': 'N', '10': 'meng', '11': '9', '12': 'cuan', '13': 'qiong', '14': '7', '15': 'e1', '16': '5', '17': '3', '18': 'Z', '19': 'zhe', '20': 'jin', '21': 'jing', '22': 'D', '23': 'xin', '24': '6', '25': 'G', '26': 'X', '27': '1', '28': '4', '29': 'gui1', '30': 'T', '31': 'S', '32': 'lu', '33': 'ning', '34': 'V', '35': 'ji', '36': 'yu', '37': 'F', '38': 'Q', '39': 'M', '40': 'L', '41': '0', '42': 'C', '43': '8', '44': 'H', '45': 'hei', '46': 'liao', '47': 'Y', '48': 'gui', '49': '2', '50': 'yu1', '51': 'zang', '52': 'yue', '53': 'sx', '54': 'min', '55': 'hu', '56': 'yun', '57': 'xiang', '58': 'B', '59': 'J', '60': 'A', '61': 'jl', '62': 'gan', '63': 'wan', '64': 'K'}, 'readme_path': '/home/aistudio/data/readme.json', 'num_epochs': 1, 'train_batch_size': 32, 'learning_strategy': {'lr': 0.001}}\n",
      "生成数据列表完成！\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "参数初始化\n",
    "'''\n",
    "src_path=train_parameters['src_path']\n",
    "target_path=train_parameters['target_path']\n",
    "train_list_path=train_parameters['train_list_path']\n",
    "eval_list_path=train_parameters['eval_list_path']\n",
    "batch_size=train_parameters['train_batch_size']\n",
    "'''\n",
    "解压原始数据到指定路径\n",
    "'''\n",
    "unzip_data(src_path,target_path)\n",
    "\n",
    "#每次生成数据列表前，首先清空train.txt和eval.txt\n",
    "with open(train_list_path, 'w') as f: \n",
    "    f.seek(0)\n",
    "    f.truncate() \n",
    "with open(eval_list_path, 'w') as f: \n",
    "    f.seek(0)\n",
    "    f.truncate() \n",
    "    \n",
    "#生成数据列表   \n",
    "get_data_list(target_path,train_list_path,eval_list_path)\n",
    "\n",
    "'''\n",
    "构造数据提供器\n",
    "'''\n",
    "train_reader = paddle.batch(data_reader(train_list_path),\n",
    "                            batch_size=batch_size,\n",
    "                            drop_last=True)\n",
    "eval_reader = paddle.batch(data_reader(eval_list_path),\n",
    "                            batch_size=batch_size,\n",
    "                            drop_last=True)\n",
    "                            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Batch=0\n",
    "Batchs=[]\n",
    "all_train_accs=[]\n",
    "def draw_train_acc(Batchs, train_accs):\n",
    "    title=\"training accs\"\n",
    "    plt.title(title, fontsize=24)\n",
    "    plt.xlabel(\"batch\", fontsize=14)\n",
    "    plt.ylabel(\"acc\", fontsize=14)\n",
    "    plt.plot(Batchs, train_accs, color='green', label='training accs')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.show()\n",
    "\n",
    "all_train_loss=[]\n",
    "def draw_train_loss(Batchs, train_loss):\n",
    "    title=\"training loss\"\n",
    "    plt.title(title, fontsize=24)\n",
    "    plt.xlabel(\"batch\", fontsize=14)\n",
    "    plt.ylabel(\"loss\", fontsize=14)\n",
    "    plt.plot(Batchs, train_loss, color='red', label='training loss')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 2、定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nclass MyDNN(fluid.dygraph.Layer):\\n    def __init__(self):\\n        super(MyDNN,self).__init__()\\n        self.hidden1 = Linear(20*20,200,act='relu')\\n        self.hidden2 = Linear(200,100,act='relu')\\n        self.hidden3 = Linear(100,100,act='relu')\\n        self.out = Linear(100,65,act='softmax')\\n    def forward(self,input):        # forward 定义执行实际运行时网络的执行逻辑\\n        x = fluid.layers.reshape(input, shape=[-1,20*20]) #-1 表示这个维度的值是从x的元素总数和剩余维度推断出来的，有且只能有一个维度设置为-1\\n        # print(x.shape)\\n        x = self.hidden1(x)\\n        # print('1', x.shape)\\n        x = self.hidden2(x)\\n        # print('2',x.shape)\\n        x = self.hidden3(x)\\n        # print('3',x.shape)\\n        y = self.out(x)\\n        # print('4',y.shape)\\n        return y\\n\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "       \n",
    "class MyLeNet(fluid.dygraph.Layer):\n",
    "    def __init__(self):\n",
    "        super(MyLeNet,self).__init__()\n",
    "        self.hidden1_1 = Conv2D(1,28,5,1) #通道数、卷积核个数、卷积核大小\n",
    "        self.hidden1_2 = Pool2D(pool_size=2,pool_type='max',pool_stride=1)\n",
    "        self.hidden2_1 = Conv2D(28,32,3,1)\n",
    "        self.hidden2_2 = Pool2D(pool_size=2,pool_type='max',pool_stride=1)\n",
    "        self.hidden3 = Conv2D(32,32,3,1)\n",
    "        self.hidden4 = Linear(32*10*10,65,act='softmax')\n",
    "    def forward(self,input):\n",
    "        #print(input.shape)\n",
    "        x = self.hidden1_1(input)\n",
    "        #print(x.shape)\n",
    "        x = self.hidden1_2(x)\n",
    "        #print(x.shape)\n",
    "        x = self.hidden2_1(x)\n",
    "        #print(x.shape)\n",
    "        x = self.hidden2_2(x)\n",
    "        #print(x.shape)\n",
    "        x = self.hidden3(x)\n",
    "        #print(x.shape)\n",
    "        x = fluid.layers.reshape(x, shape=[-1, 32*10*10])\n",
    "        y = self.hidden4(x)\n",
    "\n",
    "        return y\n",
    "\n",
    "#定义DNN网络\n",
    "'''\n",
    "class MyDNN(fluid.dygraph.Layer):\n",
    "    def __init__(self):\n",
    "        super(MyDNN,self).__init__()\n",
    "        self.hidden1 = Linear(20*20,200,act='relu')\n",
    "        self.hidden2 = Linear(200,100,act='relu')\n",
    "        self.hidden3 = Linear(100,100,act='relu')\n",
    "        self.out = Linear(100,65,act='softmax')\n",
    "    def forward(self,input):        # forward 定义执行实际运行时网络的执行逻辑\n",
    "        x = fluid.layers.reshape(input, shape=[-1,20*20]) #-1 表示这个维度的值是从x的元素总数和剩余维度推断出来的，有且只能有一个维度设置为-1\n",
    "        # print(x.shape)\n",
    "        x = self.hidden1(x)\n",
    "        # print('1', x.shape)\n",
    "        x = self.hidden2(x)\n",
    "        # print('2',x.shape)\n",
    "        x = self.hidden3(x)\n",
    "        # print('3',x.shape)\n",
    "        y = self.out(x)\n",
    "        # print('4',y.shape)\n",
    "        return y\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 3、训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0613 20:34:14.836421    99 device_context.cc:252] Please NOTE: device: 0, CUDA Capability: 70, Driver API Version: 11.2, Runtime API Version: 9.0\n",
      "W0613 20:34:14.884193    99 device_context.cc:260] device: 0, cuDNN Version: 7.6.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_pass:0,batch_id:50,train_loss:[2.409941],train_acc:[0.53125]\n",
      "train_pass:0,batch_id:100,train_loss:[1.7982004],train_acc:[0.59375]\n",
      "train_pass:0,batch_id:150,train_loss:[1.3188529],train_acc:[0.71875]\n",
      "train_pass:0,batch_id:200,train_loss:[0.85792255],train_acc:[0.8125]\n",
      "train_pass:0,batch_id:250,train_loss:[1.0683155],train_acc:[0.75]\n",
      "train_pass:0,batch_id:300,train_loss:[1.0976491],train_acc:[0.71875]\n",
      "train_pass:0,batch_id:350,train_loss:[1.2097454],train_acc:[0.75]\n",
      "train_pass:0,batch_id:400,train_loss:[0.7606518],train_acc:[0.78125]\n",
      "train_pass:0,batch_id:450,train_loss:[1.1994758],train_acc:[0.65625]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHYCAYAAAC2kBdxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3Xd4FFXfxvHvphNCEmoIHZEmvYsUEakKCooIqAj6IiKhCAjyPIqAhY6gKCIiIAryoICFIjUgSBGkKqA0aQkYxYQQCEt23z/WrASSsMluMrub+3NduZydPXvmd5Z4cTNz5ozJarVaERERERE7H6MLEBEREXE3CkgiIiIiN1FAEhEREbmJApKIiIjITRSQRERERG6igCQiIiJyEwUkERERkZsoIImIiIjcRAFJRERE5CYKSCKSLS1atMBkMmEymYiOjs61486bN89+3F69euXacY128uRJ+7jLlStndDkiXk8BSUREROQmCkgiBipXrpz9rMDJkyeNLkdERP6hgCQiIiJyEz+jCxARz5Sb845u1KtXrzw190hEjKEzSCIiIiI3UUASERERuYkCkkguu/F27d9//92+v3z58vb9N/7cfCnrxvdS7du3j0GDBlG9enUKFSqEyWSiU6dOtxx79+7djBs3jg4dOnDHHXcQEhJCQEAAERER3HPPPfz3v//l1KlTDo3Dkdv8e/XqZW8zb948AJKSknj//fdp2rQpERERBAYGUrp0abp3787WrVtve1xHbvOPjo62t2nRooV9/4YNG+jWrRt33HEHQUFBFC5cmObNmzNjxgzMZrND4wa4cuUKb7/9Nk2aNKFIkSLky5ePChUq0L17d9avX29vZ/Qk/O3btxMVFUW1atUoWLAgQUFBlCpVinbt2jFjxgwuX77sUD9Wq5Xly5fTo0cPKleuTGhoKL6+vuTPn59y5crRsmVLRowYwcaNG7FYLBn2c/jwYYYPH87dd99NkSJFCAgIICgoiGLFilGvXj169+7N/PnzuXjxoqu+ApHss4pIrjpx4oQVcPhn48aNaT5/43tWq9X62muvWX19fW/53MMPP5zmcw0aNHDoeP7+/tYJEybcdhz33ntvhjWmevrpp+1t5s6da/3555+tVatWzfT4o0aNyvS4c+fOtbd9+umn022zceNGe5t7773XmpycbO3Tp0+mx61bt671jz/+uO249+/fb61QoUKmffXt29d67do1a9myZe37Tpw4cdu+M3Pj703ZsmUzbZuYmGh9/PHHb/tnHRkZaV25cmWmfcXGxlobN27s8O/r2rVr0+0no9/T9H6eeOKJ7H5NIi6jSdoiuSw0NJT+/fsD8Mknn3Dp0iUAevbsSYECBW5pX7JkyQz7mjRpEmPGjAGgQoUKNGzYkODgYE6ePIm/v3+atqlnhgIDA6lWrRp33nknYWFhWK1WYmJi2LFjB3FxcZjNZkaMGAHA8OHDnR/wP86dO0erVq2IiYkhPDycZs2aUbx4ceLi4tiwYQPx8fEAjB07lrvuuovHH3/cZcd+7rnnmD9/Pj4+PjRq1IgqVapgsVjYvn07R44cAeCnn36iZ8+erFy5MsN+jh49yv33388ff/xh31ejRg1q166Nj48Pe/fuZd++fcyaNSvdP8vckJSURMuWLdm5c6d9X4kSJWjWrBkhISEcPXqULVu2kJKSQkxMDA899BCLFi2iS5cut/SVkpLCgw8+yO7du+37qlevTvXq1QkPD+fq1avExsayb98+YmJiMqxp+vTp9t9TgCJFinD33XcTGRmJyWTir7/+4vDhwxw6dIiUlBQXfRMiTjI6oYnkZdk5w8AN/9L28/OzhoWFWZctW3ZLu6tXr6Z53a9fP+uKFSusSUlJ6fZ7/fp169y5c6358+e3n0k6fvx4hnVk9QxSYGCgFbCOGDHCevny5TTt/vzzT2vLli3tbe+44w6rxWJJt8+snkFKPW6DBg2shw4dStPOYrFYp02bluY73bRpU7p9WiwWa/Pmze3tChcubF29evUt7davX28tVqyY1WQyWQMCAnL9DFK/fv3s7Xx9fa3Tpk2zpqSkpGnz66+/WuvVq2dvFxoamm59y5cvT3O2afv27Rke9+DBg9YRI0ZYd+zYkWa/2Wy2FilSxN7PuHHjrNeuXUu3jz///NP68ccfO3QGUySnKSCJGMjZgOTj45PhX+jZ9fnnn9v7Hz58eIbtshqQAOvIkSMz7C82NtYezoAM/zLOakACrBUrVrReunQpw2N36dLF3vb5559Pt82qVavSfO9btmzJsL8ff/zxlstJuRGQjh49avXx8bG3mzFjRob9/fXXX9Zy5crZ2/bu3fuWNkOHDrW/P3v27GzVfeDAAXsfTZo0yVYfIkbQJG0RD9alSxeaN2/u8j5DQkIAWLduncv6LVq0KKNGjcrw/YiICB588EH76xsvETlr/Pjx9jGl55lnnrntcefMmWPf7tatG02aNMmwv/r169OzZ89sVOqc2bNn2ydJ165dmxdeeCHDtgULFmTChAn21wsXLrRf5kyVkJBg3y5atGi2anJFHyJG0BwkEQ/WrVu3bH1u//797Nmzh5MnT5KQkEBycnKa91PvkDtw4AAWiwUfH+f/LdWxY0eCgoIybVOnTh3+97//Abjsrq+goCA6dux42+Omyui4mzZtsm8/+eSTtz3uk08+ydy5cx0r0kU2bNhg3069gzAznTt3plChQvz1118kJyezbds22rVrZ3+/dOnS9u3Zs2fToUMHfH19s1TTjX1s3LiRX3/9lUqVKmWpDxEjKCCJeLB69eplqf38+fN56623+PXXXx1qbzabiY+Pp2DBgtkpL40aNWrctk3hwoXt2zeeeXBG5cqVb5mwntXjnj17Ns3E7EaNGt32uA0aNMBkMmG1WrNQbfZZrVb27t1rf33PPffc9jP+/v40bNiQ1atXA7aJ6jcGpC5dujB69GgsFgsrVqygevXqPPPMM7Rv355q1ardNoCBLSDdfffdbN++nfj4eOrVq8dTTz1F586dadKkCcHBwdkYrUjO0yU2EQ/m6CULq9XKM888Q69evRwOR6lS77JzVlhY2G3b3BhksrIukSuPe/369VvevzEcBQcHU6hQodv2WaBAAYeO7Srx8fFpvrOyZcs69Lly5crZt+Pi4tK8V7VqVSZOnGgPQqnrGNWoUYPChQvToUMHJk2adNvfqTlz5hAREQFAYmIiM2fOpE2bNoSFhdGgQQOGDh3KmjVrdAebuBUFJBEPli9fPofazZ49O83lnnbt2jF//nwOHDjAxYsXSU5Oxmq7aQOr1ZrmL9fMFv7LCkfONuQEVxw3MTHRvp2VMx6ZzXtytRtrBMifP79Dn7uxXXpheOjQoWzcuJH7778/zXd58eJFVqxYwfDhw6lcuTKtWrXiwIED6R7jrrvuYt++fQwYMCBNaLx+/Tq7du1i6tSptG3blrJly/LRRx85VLdITlNAEskDJk+ebN8eM2YMq1atomfPnvb1bAICAtK0d9VZI29xY9BJSkpy+HOOrlTtCjeHMUePfWO7jNZuuvfee1m3bh0xMTEsXryYgQMHUrdu3TRz09avX0+jRo0yXA09IiKCd955h/PnzxMdHc3rr79O+/btCQ0Ntbc5e/Ysffr0YeDAgQ7VLpKTFJBEvNzp06f57bffAAgPD2fkyJGZtk9ISNCjHm5SpEgR+3ZSUpJD309iYiJ///13TpaVRlhYWJpLhY4+MubGSek3jjM9ERERdO3alenTp7N7925iY2OZNm2afQ7XlStX6Nu3b6Z9BAYGcu+99/LKK6+wcuVK4uLiWLVqFU2bNrW3effdd/nxxx8dql8kpyggiRgoNy47nTt3zr5dpUqV205Y3rJlS65NLPYUpUqVShMeduzYcdvP7Nq1K1e/R5PJRO3ate2vf/jhh9t+5vr162mCSN26dbN0zKJFizJo0CC++uor+76ff/6Z48ePO9yHv78/7dq1Y926dVSvXt2+/5tvvslSLSKupoAkYqAbb3t31aTkm914GcSRy0MzZ87MkTo83b333mvf/uyzz27b/tNPP83JctLVsmVL+/b8+fNvG9CWL1/On3/+Cdh+Fxs3bpyt4zZp0iTNxPXz589nuY/AwEDatGnjVB8irqSAJGKgG28vP3v2bI4co3z58vYzVQcPHsz0X/eLFy/m22+/zZE6PN2Ni0kuXLiQ7du3Z9j2p59+Yv78+blRVhp9+vSxB+KffvqJDz/8MMO2f//9d5pn7XXv3v2Wu+5uvqsts75unCRerFgx+/bFixcdnuh/+vTpdPsQMYICkoiBbryksGTJkhw5RuqDQcF2R1qXLl3sD2hNZbFYeO+993jqqafw9fW97YKOeVH79u3t82QsFgsdO3ZMd6Xx6OhoHnjgAVJSUm6Z/J7TKlSokGYOUFRUFO+9994tAeXo0aO0adOGEydOALYHKKe3ynnXrl3p0KEDX3zxRYZnH8+ePUuPHj24du0aAJUqVaJChQr297/66isqVarE5MmTM1yEMzk5mRkzZvDFF1/Y97Vv396xQYvkEC0UKWKgRx99lFmzZgHw/vvvs3v3burWrZvmVvJ+/fql+QsnO15//XXatGmDxWJhz5491KhRgyZNmnDHHXeQmJjI999/b38a+5tvvsmHH37I77//7tQxvY3JZOLjjz+mcePG/Pnnn8TFxdG6dWtq1apln/uzb98++2KNw4YNY8mSJfbv0RWrkTti8uTJ7Nq1ix9//JHr168TFRXF+PHjadq0KSEhIRw7dozNmzfb1xzy8/Njzpw5adZDSpW6QOSKFSsICAigWrVqVKpUibCwMC5dusSpU6fYtm2bPYD5+voyffr0W/o5duwYL730Ei+99BJlypShZs2a9jNEsbGxbN++nb/++sve/oknnnBooUuRHGXYU+BExGq1Wq3du3dP81DTm39ufhDsje9lxcyZM61+fn4ZHsfHx8c6atQoq8Viceghull9WO3cuXNvW6MjD6LN6sNq77333tse12p1/Hvdu3evtXz58pn+mT333HPWa9euWUuUKGHfd/HiRYfqyIgjD6tNdenSJWvXrl0zrRGwRkZGWleuXJlhPx06dLhtH6k/xYoVsy5fvvyWPpYsWWI1mUwO9eHj42N94YUXrNeuXXPquxJxBZ1BEjHYZ599RocOHVi0aBF79+4lLi6Oq1evuvw4zz//PE2aNOHtt99m48aNnDt3jnz58lGyZElatmzJM888k+aZZJK+WrVqcfDgQT744AOWLFnCr7/+SlJSEpGRkTRs2JA+ffpw//33A9iXA/Dx8Umz3k9OCwkJYfHixQwePJgFCxYQHR3NuXPnuHLlCkWKFKF69ep06NCBZ555JtMFJb/++mv27NnD+vXr2bFjB4cOHeLMmTNcvnyZwMBAihYtSs2aNXnggQfo0aNHumPs0qULMTExrFmzhq1bt7Jv3z6OHz9uXwIhLCyMSpUq0bRpU3r27Mldd92VY9+LSFaYrFbdzysi4mq//fab/aGsVapU4dChQwZXJCJZoUnaIiI5YPHixfbtBg0aGFiJiGSHApKIiIudOHEizeNdevToYWA1IpIdCkgiIlnQpk0bVq9ezfXr19N9f8WKFTRt2pT4+HgAateunWYBRBHxDJqDJCKSBamLbhYsWJC6detSunRpAgICiIuLY+fOnZw5c8betkCBAmzdupUaNWoYVa6IZJMCkohIFjj6/LyKFSuyZMkSatWqlcMViUhO0G3+IiJZcPDgQZYvX84PP/zA77//TlxcHH/99RdBQUEULVqUhg0b0qFDB7p164avr6/R5YpINukMkoMsFgvnzp2jQIECufIEdhEREXGe1Wrl0qVLlChRIksr2usMkoPOnTtH6dKljS5DREREsuH06dOUKlXK4fYKSA4qUKAAYPuCXb0irtlsZs2aNbRp0wZ/f3+X9u0OND7P5+1j1Pg8n7ePUePLvoSEBEqXLm3/e9xRCkgOSr2sFhoamiMBKTg4mNDQUK/9xdf4PJu3j1Hj83zePkaNz3lZnR6jdZBEREREbqKAJCIiInITBSQRERGRm2gOkoiIeJyUlBTMZrP9tdlsxs/Pj6tXr5KSkmJgZTlD48uYv79/jqw5poAkIiIew2q1Ehsby99//33L/uLFi3P69GmvXKtO48tceHg4xYsXd+l3o4AkIiIeIzUcFStWjODgYPtfiBaLhcTEREJCQrK0GKCn0PjSZ7VaSUpK4sKFCwBERka6rCYFJBER8QgpKSn2cFS4cOE071ksFq5du0ZQUJDXBgiNL3358uUD4MKFCxQrVsxll9u871sWERGvlDrnKDg42OBKxN2k/k7cOC/NWQpIIiLiUbxxDo44Jyd+JxSQRERERG6igCQiIuJhypUrx7Rp0xxuHx0djclkuuXuP1ebN28e4eHhOXqM3KJJ2iIiIjmsRYsW1K5dO0uhJjM//vgj+fPnd7j9PffcQ0xMDGFhYS45fl6ggOQO9uwhMIdTvYiIuDer1UpKSgp+frf/q7lo0aJZ6jsgIIDixYtnt7Q8SZfYjDZ0KP6NGnHHN98YXYmIiOSAXr16sWnTJqZPn47JZMJkMnHy5En7Za9Vq1ZRr149AgMD2bJlC8eOHePhhx8mIiKCkJAQGjRowLp169L0efMlNpPJxEcffUTnzp0JDg6mYsWKfP311/b3b77Elnop7LvvvqNq1aqEhITQrl07YmJi7J+5fv06AwcOJDw8nMKFCzNixAiefvppOnXqlKXxz5w5kwoVKhAQEEDlypVZsGCB/T2r1cro0aMpV64cERERlCpVioEDB9rff//996lYsSJBQUFERETQpUuXLB3bGQpIRmvWDIByq1dDYqLBxYiIeBirFS5fzv0fq9XhEqdPn07jxo3p06cPMTExxMTEULp0afv7L7/8MuPHj+fQoUPUrFmTxMREHnjgAdavX8+ePXto164dDz/8MKdPn870OGPGjKFr167s37+fBx54gCeeeIK//vorw/ZJSUlMnjyZBQsWsHnzZk6dOsWwYcPs70+YMIHPPvuMuXPnsnXrVhISEli+fLnD4wZYtmwZgwYNYujQoRw8eJC+ffvSu3dvNm7cCMCXX37J22+/zcyZM9m1axdLly6lRo0aAOzatYuBAwcyduxYjhw5wurVq2nevHmWju8MXWIzWseOWO+8k4CjR0mZNw9efNHoikREPEdSEoSE4APk6tTgxERwcA5QWFgYAQEBBAcHp3uZa+zYsbRu3dr+ulChQtSqVcv++vXXX2fZsmWsWrWKatWqZXicXr160b17dwDeeust3nnnHXbu3Em7du3SbW82m/nggw+oUKECAFFRUYwdO9b+/rvvvsvIkSPp3LkzADNmzGDlypUOjTnV5MmT6dWrFy+88AIAQ4YMYfv27UyePJn77ruPU6dOUbx4cVq1asWVK1cIDQ3l7rvvBuDUqVPkz5+fDh06UKBAAcqWLUudOnWydHxn6AyS0Xx9sQweDIDPO+/A9esGFyQiIrmpfv36aV4nJiYybNgwqlatSnh4OCEhIRw6dIgzZ85k2k/NmjXt2/nz5yc0NNT+CI70BAcH28MR2B7Tkdo+Pj6e8+fP07BhQ/v7vr6+1KtXL0tjO3ToEE2aNEmzr0mTJhw6dAiAxx57jCtXrnDnnXcyaNAgli1bxvV//h5s3bo1ZcuW5Y477uCpp57is88+IykpKUvHd4YCkhuwPPkkyaGhmE6ehGXLjC5HRMRzBAdDYiKWhAT+PnMGS0KC7exOTv+4cDXvm+9GGzZsGMuWLeOtt97i+++/Z+/evdSoUeO2q0T7+/uneW0ymbBYLFlqb83CpUNXKF26NEeOHGHGjBkEBQURFRVF8+bNMZvNFChQgJ9++olFixYRGRnJqFGjqFWrVo4vVZBKAckdBAdzon172/akSVm6ti0ikqeZTLZLXbn9k8WVmwMCAkhJSXGo7datW+nVqxedO3emRo0aFC9enJMnT2bjy8m+sLAwIiIi+PHHH+37UlJS+Omnn7LUT9WqVdm6dWuafVu3buWuu+6yv86XLx8dO3ZkwoQJbNiwgW3btnHgwAEA/Pz8aNWqFRMnTmT//v2cPHmSDRs2ODEyx2kOkps40b49lZcvx/Tjj7Bli33ytoiIeL5y5cqxY8cOTp48SUhICIUKFcqwbcWKFVm6dCkdO3bEZDLx6quvZnomKKcMGDCAcePGceedd1KlShXeffddLl68mKXHerz00kt07dqVOnXq0KpVK7755huWLl1qvytv3rx5pKSk0KBBAywWC1988QX58uWjbNmyfPvttxw/fpzmzZtTsGBBVq5cicVioXLlyjk15DR0BslNXAsPx/LUU7YXkycbW4yIiLjUsGHD8PX15a677qJo0aKcOnUqw7ZTp06lYMGC3HPPPXTs2JG2bdtSt27dXKzWZsSIEXTv3p2ePXvSuHFjQkJCaNu2LUFBQQ730alTJ6ZPn87kyZOpVq0as2bNYu7cubRo0QKA8PBwZs+eTbNmzWjatCnr16/nm2++oXDhwoSHh7N06VJatmxJ1apV+eCDD1i0aFGmE9VdyWTN7QuOHiohIYGwsDDi4+MJDQ11ad9ms5mVK1fyQIUK+P9zeyOHD0MupeScZh/fAw/ccs3bG3j7+MD7x6jxeYarV69y4sQJypcvf8tf0haLhYSEBEJDQ/Hx8b5/+7vD+CwWC1WrVqVr1668/vrrLu/bmfFl9ruR3b+/ve+3yJNVrgwPPWTbfvttY2sREZE87ffff2f27Nn8+uuvHDhwgH79+nHixAl69OhhdGm5QgHJ3Qwdavvv/PmQye2ZIiIiOcnHx4d58+bRoEEDmjRpwoEDB1i3bh1Vq1Y1urRcoUna7qZZM2jQAH78Ed5/H0aPNroiERHJg0qXLn3LHWh5ic4guRuTCVKXen/vPbhyxdh6RERE8iAFJHf0yCNQrhzExcEnnxhdjYiIW9G9RXKznPidUEByR35+/z6TbcoUMGD9CxERd5N6B15uPm5CPEPq74Qr79LUHCR39cwz8Npr8Ntv8M038PDDRlckImIoX19fwsPD7c8LCw4Oti9aaLFYuHbtGlevXvXa2/w1vltZrVaSkpK4cOEC4eHh+Pr6uqwmBSR3FRICzz8P48fbFo5UQBIRoXjx4gC3PITVarVy5coV8uXLl6WVnj2Fxpe58PBw+++GqyggubMBA2yX2LZsgR07oFEjoysSETGUyWQiMjKSYsWKpXl4q9lsZvPmzTRv3tyjF8PMiMaXMX9/f5eeOUqlgOTOSpSAJ56AefNsQel//zO6IhERt+Dr65vmL0VfX1+uX79OUFCQVwYIjS/3ed+FTG+TunDkl1/C8ePG1iIiIpJHKCC5u+rVoW1b251s06YZXY2IiEieoIDkCVIXjpwzB/76y9haRERE8gAFJE9w//1QqxYkJcGsWUZXIyIi4vUUkDzBjY8feecdSE42th4REREvp4DkKR5/HEqWhNhYWLjQ6GpERES8mgKSp/D3h0GDbNtTpoCeRSQiIpJjFJA8yXPPQYEC8PPP8N13RlcjIiLitRSQPElYGPTpY9uePNnYWkRERLyYApKnGTQIfH1h/XrYs8foakRERLyS2wWkcePG0aBBAwoUKECxYsXo1KkTR44cyfQzs2fPplmzZhQsWJCCBQvSqlUrdu7cmaZNr169MJlMaX7atWuXk0PJGWXKQNeutu0pU4ytRURExEu5XUDatGkT/fv3Z/v27axduxaz2UybNm24fPlyhp+Jjo6me/fubNy4kW3btlG6dGnatGnD2bNn07Rr164dMTEx9p9Fixbl9HByRurjRz7/HE6fNrYWERERL+R2D6tdvXp1mtfz5s2jWLFi7N69m+bNm6f7mc8++yzN648++ogvv/yS9evX07NnT/v+wMBAihcv7vqic1u9enDffbBxo21dpEmTjK5IRETEq7jdGaSbxcfHA1CoUCGHP5OUlITZbL7lM9HR0RQrVozKlSvTr18//vzzT5fWmqtSF46cNQv++Y5ERETENdzuDNKNLBYLgwcPpkmTJlSvXt3hz40YMYISJUrQqlUr+7527drxyCOPUL58eY4dO8Z//vMf2rdvz7Zt2/D19b2lj+TkZJJvWLE6ISEBALPZjNlsdmJUt0rtL0v93n8/flWqYDp8mJRZs7C8+KJLa3KlbI3Pg3j7+MD7x6jxeT5vH6PG53zfWWWyWt13xcF+/fqxatUqtmzZQqlSpRz6zPjx45k4cSLR0dHUrFkzw3bHjx+nQoUKrFu3jvvvv/+W90ePHs2YMWNu2b9w4UKCg4MdH0QOKrN2LXXee48rhQuzdtYsrH5unXdFRERyXVJSEj169CA+Pp7Q0FCHP+e2ASkqKoqvvvqKzZs3U758eYc+M3nyZN544w3WrVtH/fr1b9u+aNGivPHGG/Tt2/eW99I7g1S6dGni4uKy9AU7wmw2s3btWlq3bo2/v7/jH7x6Fb+KFTGdP8/1+fOxdu/u0rpcJdvj8xDePj7w/jFqfJ7P28eo8WVfQkICRYoUyXJAcrtTDlarlQEDBrBs2TKio6MdDkcTJ07kzTff5LvvvnMoHJ05c4Y///yTyMjIdN8PDAwkMDDwlv3+/v459suZ5b79/WHAAHjlFfymTYOnnrI92NZN5eR35w68fXzg/WPU+Dyft49R48ten9nhdpO0+/fvz6effsrChQspUKAAsbGxxMbGcuXKFXubnj17MnLkSPvrCRMm8Oqrr/Lxxx9Trlw5+2cSExMBSExM5KWXXmL79u2cPHmS9evX8/DDD3PnnXfStm3bXB+jSz3/PAQH2xaN3LjR6GpERES8gtsFpJkzZxIfH0+LFi2IjIy0/yxevNje5tSpU8TExKT5zLVr1+jSpUuaz0z+53Ecvr6+7N+/n4ceeohKlSrx7LPPUq9ePb7//vt0zxJ5lMKFoXdv27YePyIiIuISbnmJ7Xaio6PTvD558mSm7fPly8d33vxw1xdfhPffh1WrbA+yrVbN6IpEREQ8mtudQZJsqFABHnnEtj11qrG1iIiIeAEFJG+RunDkp5/CDZcfRUREJOsUkLzF3XfDPffAtWswY4bR1YiIiHjChTRxAAAgAElEQVQ0BSRvknoWaeZMyOThviIiIpI5BSRv8tBDcOedcPEizJ1rdDUiIiIeSwHJm/j6wpAhtu2pUyElxdh6REREPJQCkrd5+mnb2kgnTsCyZUZXIyIi4pEUkLxNcDC88IJte/JkcM9H7YmIiLg1BSRv1L8/BAbCjh3www9GVyMiIuJxFJC8UUQE9Oxp29bjR0RERLJMAclbpU7W/uor+PVXY2sRERHxMApI3qpKFejQwTYH6e23ja5GRETEoyggebPUhSPnzYM//jC0FBEREU+igOTNmjeH+vXh6lXb6toiIiLiEAUkb2Yy/XsWacYMuHLF2HpEREQ8hAKSt3v0UShb1naJbcECo6sRERHxCApI3s7PDwYPtm1PmQIWi7H1iIiIeAAFpLzg2WchLMx2u/+KFUZXIyIi4vYUkPKCAgXg+edt21o4UkRE5LYUkPKKAQPA3x82b4adO42uRkRExK0pIOUVJUtCjx627SlTjK1FRETEzSkg5SWpjx/54gs4ccLYWkRERNyYAlJeUrMmtGlju5Nt+nSjqxEREXFbCkh5TerCkR99BBcvGluLiIiIm1JAymtatbKdSbp8GWbNMroaERERt6SAlNeYTDB0qG37nXfg2jVj6xEREXFDCkh5UbduUKIExMTAokVGVyMiIuJ2FJDyooAAGDTItj15MlitxtYjIiLiZhSQ8qrnnoOQEDh4ENasMboaERERt6KAlFeFh0OfPrZtPX5EREQkDQWkvGzQIPD1hXXrYN8+o6sRERFxGwpIeVnZsvDYY7ZtPX5ERETETgEpr0u95X/RIjhzxthaRERE3IQCUl5Xvz60aAHXr9vWRRIREREFJOHfs0izZkFCgrG1iIiIuAEFJIEHHoAqVWzhaM4co6sRERExnAKSgI/Pv2eRpk0Ds9nYekRERAymgCQ2Tz4JxYrBqVPwxRdGVyMiImIoBSSxCQqCAQNs23r8iIiI5HEKSPKvfv0gXz746SfYtMnoakRERAzjdgFp3LhxNGjQgAIFClCsWDE6derEkSNHbvu5JUuWUKVKFYKCgqhRowYrV65M877VamXUqFFERkaSL18+WrVqxW+//ZZTw/BMhQtD7962bT1+RERE8jC3C0ibNm2if//+bN++nbVr12I2m2nTpg2XL1/O8DM//PAD3bt359lnn2XPnj106tSJTp06cfDgQXubiRMn8s477/DBBx+wY8cO8ufPT9u2bbl69WpuDMtzvPgimEywYgX88ovR1YiIiBjC7QLS6tWr6dWrF9WqVaNWrVrMmzePU6dOsXv37gw/M336dNq1a8dLL71E1apVef3116lbty4zZswAbGePpk2bxiuvvMLDDz9MzZo1+eSTTzh37hzLly/PraF5hjvvhM6dbdtTpxpbi4iIiEH8jC7gduLj4wEoVKhQhm22bdvGkCFD0uxr27atPfycOHGC2NhYWrVqZX8/LCyMRo0asW3bNrp163ZLn8nJySQnJ9tfJ/yzgKLZbMbs4tvgU/tzdb/ZZRo0CL+lS7EuWMD1116D4sWd6s/dxudq3j4+8P4xanyez9vHqPE533dWuXVAslgsDB48mCZNmlC9evUM28XGxhIREZFmX0REBLGxsfb3U/dl1OZm48aNY8yYMbfsX7NmDcHBwVkah6PWrl2bI/1mR7PKlSl05AjHhw7l8BNPuKRPdxpfTvD28YH3j1Hj83zePkaNL+uSkpKy9Tm3Dkj9+/fn4MGDbNmyJdePPXLkyDRnpRISEihdujRt2rQhNDTUpccym82sXbuW1q1b4+/v79K+s8uUnAyPP06l9eu548MPIX/+bPfljuNzJW8fH3j/GDU+z+ftY9T4si8hm4/QctuAFBUVxbfffsvmzZspVapUpm2LFy/O+fPn0+w7f/48xf+5NJT63/PnzxMZGZmmTe3atdPtMzAwkMDAwFv2+/v759gvZ072nWWPPgoVKmA6dgz/zz6D/v2d7tKtxpcDvH184P1j1Pg8n7ePUePLXp/Z4XaTtK1WK1FRUSxbtowNGzZQvnz5236mcePGrF+/Ps2+tWvX0rhxYwDKly9P8eLF07RJSEhgx44d9jZyE19fSD2DNnUqpKQYW4+IiEgucruA1L9/fz799FMWLlxIgQIFiI2NJTY2litXrtjb9OzZk5EjR9pfDxo0iNWrVzNlyhQOHz7M6NGj2bVrF1FRUQCYTCYGDx7MG2+8wddff82BAwfo2bMnJUqUoFOnTrk+Ro/RqxcUKgTHj8NXXxldjYiISK5xu4A0c+ZM4uPjadGiBZGRkfafxYsX29ucOnWKmJgY++t77rmHhQsX8uGHH1KrVi2++OILli9fnmZi9/DhwxkwYADPPfccDRo0IDExkdWrVxMUFJSr4/MowcHwwgu2bS0cKSIieYjbzUGyOvAMsOjo6Fv2PfbYYzz22GMZfsZkMjF27FjGjh3rTHl5T1QUTJwI27bBDz/APfcYXZGIiEiOc7szSOJmIiKgZ0/bts4iiYhIHqGAJLeXOll7+XI4etTYWkRERHKBApLcXtWq8OCDYLXC228bXY2IiEiOU0ASxwwbZvvv3LkQF2dsLSIiIjlMAUkcc++9UK8eXLkCM2caXY2IiEiOUkASx5hM/55FmjEDrl41th4REZEcpIAkjuvSBcqUgQsX4NNPja5GREQkxyggieP8/GDwYNv2lClgsRhbj4iISA5RQJKs+b//g7AwOHwYVq40uhoREZEcoYAkWVOgAPTta9vWwpEiIuKlFJAk6wYMsF1u27QJdu0yuhoRERGXU0CSrCtVCrp3t21PmWJsLSIiIjlAAUmyZ+hQ23+XLIGTJw0tRURExNUUkCR7atWC1q0hJQWmTze6GhEREZdSQJLsS1048qOP4O+/ja1FRETEhRSQJPtat4YaNSAxET780OhqREREXEYBSbLPZPp3LtL06XDtmrH1iIiIuIgCkjine3coUQLOnYPPPze6GhEREZdQQBLnBATAwIG27cmTwWo1th4REREXUEAS5/XtCyEhcOAArFtndDUiIiJOU0AS54WHw7PP2rb1+BEREfECCkjiGoMHg48PrFkD+/cbXY2IiIhTFJDENcqVg8ces23r8SMiIuLhFJDEdVIXjly0CM6eNbYWERERJyggievUrw/Nm4PZDO++a3Q1IiIi2aaAJK6Vehbpgw/g0iVjaxEREckmBSRxrQcfhMqVIT4e5swxuhoREZFsUUAS1/Lx+ffxI9OmwfXrxtYjIiKSDQpI4npPPQXFisHvv8OXXxpdjYiISJYpIInrBQVB//627UmT9PgRERHxOApIkjNeeMEWlHbvxvT990ZXIyIikiUKSJIzihSB3r0B8Jk61eBiREREskYBSXLOiy+CyYTPypWEnDljdDUiIiIOU0CSnFOxIjz8MAAVvvrK4GJEREQcp4AkOeufhSNLb9wIx44ZXIyIiIhjFJAkZzVpgqVNG3yvX8d3xAijqxEREXGIApLkuJRJk7D4+ODz9dewbp3R5YiIiNyWApLkvKpVOfHAA7btwYO1uraIiLg9BSTJFUe6dcNauDD8/DPMmmV0OSIiIplSQJJcYQ4JwTJ6tO3FqFHw11+G1iMiIpIZtwtImzdvpmPHjpQoUQKTycTy5cszbd+rVy9MJtMtP9WqVbO3GT169C3vV6lSJaeHIjexPPss1KhhC0epYUlERMQNuV1Aunz5MrVq1eK9995zqP306dOJiYmx/5w+fZpChQrx2GOPpWlXrVq1NO22bNmSE+VLZvz8YNo02/b779sut4mIiLghP6MLuFn79u1p3769w+3DwsIICwuzv16+fDkXL16k9z+PuUjl5+dH8eLFXVanZFPLltC5MyxbZltp+7vvwGQyuioREZE03C4gOWvOnDm0atWKsmXLptn/22+/UaJECYKCgmjcuDHjxo2jTJkyGfaTnJxMcnKy/XVCQgIAZrMZs9ns0ppT+3N1v+7ilvGNG4ffihWY1q7l+vLlWDt0MLA653n7nx94/xg1Ps/n7WPU+JzvO6tMVqvV6uJaXMZkMrFs2TI6derkUPtz585RpkwZFi5cSNeuXe37V61aRWJiIpUrVyYmJoYxY8Zw9uxZDh48SIECBdLta/To0YwZM+aW/QsXLiQ4ODh7AxK7qgsWUOnLL0mMjGTjO+9g8fc3uiQREfFCSUlJ9OjRg/j4eEJDQx3+nFcFpHHjxjFlyhTOnTtHQEBAhu3+/vtvypYty9SpU3n22WfTbZPeGaTSpUsTFxeXpS/YEWazmbVr19K6dWv8vTAopDu+S5fwq1YNU2wsKePGYRk61NgineDtf37g/WPU+Dyft49R48u+hIQEihQpkuWA5DWX2KxWKx9//DFPPfVUpuEIIDw8nEqVKnH06NEM2wQGBhIYGHjLfn9//xz75czJvt1BmvEVKgTjx0OvXvi+9Ra+vXtDRISxBTrJ2//8wPvHqPF5Pm8fo8aXvT6zw+3uYsuuTZs2cfTo0QzPCN0oMTGRY8eOERkZmQuVSYaeegoaNIBLl+C//zW6GhERETu3C0iJiYns3buXvXv3AnDixAn27t3LqVOnABg5ciQ9e/a85XNz5syhUaNGVK9e/Zb3hg0bxqZNmzh58iQ//PADnTt3xtfXl+7du+fsYCRzPj4wfbpt++OPYfduY+sRERH5h9sFpF27dlGnTh3q1KkDwJAhQ6hTpw6jRo0CICYmxh6WUsXHx/Pll19mePbozJkzdO/encqVK9O1a1cKFy7M9u3bKVq0aM4ORm6vcWN44gmwWmHQINt/RUREDOZ2c5BatGhBZvPG582bd8u+sLAwkpKSMvzM559/7orSJKeMH29bF2nrVli8GLp1M7oiERHJ49zuDJLkQaVKwciRtu2XXoJMwq6IiEhuUEAS9zB0KJQtC2fOwKRJRlcjIiJ5nAKSuId8+f4NRhMmwE3zzERERHKTApK4jy5doHlzuHIFRowwuhoREcnDFJDEfZhMttv+TSb4/HPYssXoikREJI9SQBL3Urs29Olj2x40CCwWY+sREZE8SQFJ3M8bb0BYGPz0E6SzrIOIiEhOU0AS91O0KPyzMCgjR0JCgrH1iIhInqOAJO4pKgoqVYILF2xnlERERHKRApK4p4AAePtt2/a0afDbb8bWIyIieYoCkrivBx6A9u3BbIZhw4yuRkRE8hAFJHFvU6eCnx98/TWsWWN0NSIikkc4FZBOnz7Nhg0b0jwo1mKxMGHCBJo0aUKrVq1YsWKF00VKHlalim0+EsCLL8L168bWIyIieYJTAenVV1/lsccew9/f377vzTffZOTIkWzbto0NGzbQqVMnfvzxR6cLlTxs1CgoUgR++QU++MDoakREJA9wKiBt3bqVVq1a2QOS1WplxowZVKlShVOnTrFz507y58/PJD18VJxRsOC/d7KNGgV//mlsPSIi4vWcCkgXLlygbNmy9td79+7ljz/+YMCAAZQqVYr69evrDJK4xv/9H9SsCRcvwmuvGV2NiIh4OacCksViwXLDoyCio6MxmUy0bNnSvq9kyZLExsY6cxgR8PW13e4PMHMmHDhgbD0iIuLVnApIZcqUYefOnfbXy5cvJzIyksqVK9v3xcbGEh4e7sxhRGzuuw8efdT2fLYXXwSr1eiKRETESzkVkB599FG2bt1Kly5dePLJJ9myZQuPPvpomja//PILd9xxh1NFithNmgSBgbB+ve3WfxERkRzgVEAaNmwYDRo0YOnSpSxcuJAaNWowevRo+/u///47O3fupEWLFk6WKfKP8uVh6FDb9pAhkJxsbD0iIuKVnApIoaGhbN++nf3797N//352795NwYIF07RZunQpL7zwglNFiqQxciRERsLx4//OSxIREXEhl6ykXb16dapXr46vr2+a/WXLluXhhx+mZMmSrjiMiE1ICEyYYNt+4w2IiTG2HhER8TpOBaRLly5x/PhxzGZzmv2LFy/miSee4P/+7//Ys2ePUwWKpOuJJ6BRI0hMhP/+1+hqRETEyzgVkIYPH06tWrXSBKSZM2fSo0cPFi1axMcff0zTpk05fPiw04WKpOHjA9On27bnzgWttSUiIi7kVEDatGkTrVq1Ijg42L5v/PjxlCxZks2bN/O///0Pq9WqlbQlZzRqBE89ZdseNEi3/YuIiMs4FZBiYmIoX768/fWhQ4c4ffo0AwcOpGnTpnTp0oWHHnqIzZs3O12oSLrGjYP8+WHbNli0yOhqRETESzgVkJKTkwkICLC/3rRpEyaTiTZt2tj33XHHHZw9e9aZw4hkrGRJ+M9/bNsjRsDly8bWIyIiXsGpgFSqVCn2799vf/3tt99SqFAhatasad/3559/EhIS4sxhRDI3ZAiUKwdnzsDEiUZXIyIiXsCpgNS+fXvWrFnDsGHDeOWVV1i9ejUdO3ZM0+bXX3+lTJkyThUpkqmgIJg82bY9cSL8/rux9YiIiMdzKiCNHDmSMmXKMHXqVN566y0iIiIYO3as/f0LFy6wdetWmjdv7nShIpl65BFo0QKuXoXhw42uRkREPJyfMx8uXrw4P//8M+vXrwegefPmhIaG2t+Pi4tj0qRJtG3b1rkqRW7HZLKtql23LvzvfxAVBc2aGV2ViIh4KKcCEkC+fPno0KFDuu/ddddd3HXXXc4eQsQxtWpBnz4wa5bttv8ff4SbVncXERFxhEseNQJw9uxZVqxYwaJFi1ixYoXuXBNjvP46hIXBnj22BSRFRESywemAdPToUVq3bk2ZMmV46KGHePLJJ3nooYcoU6YMbdq04ejRo66oU8QxRYvC6NG27f/8B+LjDS1HREQ8k1OX2E6fPk3Tpk25cOECVapUoXnz5kRGRhIbG8vmzZtZt24dzZo1Y+fOnZQuXdpVNYtkrn9/22W2w4dtD7PVSu4iIpJFTgWkMWPGcOHCBd5//3369u2LyWRK8/6sWbPo168fY8eOZfbs2U4VKuIwf3+YOhUeeMD2vLY+faBSJaOrEhERD+LUJbbvvvuOjh078vzzz98SjgD69u1Lx44dWbVqlTOHEcm69u1tAclshqFDja5GREQ8jFMB6cKFC1SvXj3TNtWrV+ePP/5w5jAi2TN1Kvj5wbffwurVRlcjIiIexKmAVLRoUX755ZdM2/zyyy8ULVrUmcOIZE/lyjBwoG37xRdtZ5NEREQc4FRAatu2LV9//TVz5sxJ9/2PP/6Yb775hnbt2jlzGJHse/VV251thw/DzJlGVyMiIh7CqYD02muvUbhwYZ577jlq1KhBVFQUr7/+OlFRUdSsWZM+ffpQuHBhXnvtNYf73Lx5Mx07dqREiRKYTCaWL1+eafvo6GhMJtMtP7GxsWnavffee5QrV46goCAaNWrEzp07szVm8TDh4bY72QBeew3i4oytR0REPIJTd7GVKVOGrVu30rdvX6Kjo/n555/TvH/fffcxc+bMLN3if/nyZWrVqsUzzzzDI4884vDnjhw5kuYxJ8WKFbNvL168mCFDhvDBBx/QqFEjpk2bRtu2bTly5EiaduKlnn0W3n8f9u2DUaNs2yIiIplw+lEjFStWZMOGDZw+fZq9e/eSkJBAaGgotWvXztbaR+3bt6d9+/ZZ/lyxYsUIDw9P972pU6fSp08fevfuDcAHH3zAihUr+Pjjj3n55ZezfCzxML6+ttv9W7SwrY/0/PNQs6bRVYmIiBtzOiClKl26tKGLQdauXZvk5GSqV6/O6NGjadKkCQDXrl1j9+7djBw50t7Wx8eHVq1asW3btgz7S05OJjk52f46ISEBALPZjNnFk31T+3N1v+7CLcZ3zz34PvooPl9+iWXQIFK++872gFsXcIvx5TBvH6PG5/m8fYwan/N9Z5XJarVaHW38zDPPZO8gJlOGE7lv97lly5bRqVOnDNscOXKE6Oho6tevT3JyMh999BELFixgx44d1K1bl3PnzlGyZEl++OEHGjdubP/c8OHD2bRpEzt27Ei339GjRzNmzJhb9i9cuJDg4OAsj0WMl+/8ee6PisLXbGbnyy8Tc/fdRpckIiI5LCkpiR49ehAfH59mKs7tZCkg+fhkb063yWQiJSUlW5+7XUBKz7333kuZMmVYsGBBtgNSemeQSpcuTVxcXJa+YEeYzWbWrl1L69at8ff3d2nf7sCdxufz2mv4jhuHtXx5ru/bB0FBTvfpTuPLKd4+Ro3P83n7GDW+7EtISKBIkSJZDkhZusR24sSJLBdmhIYNG7JlyxYAihQpgq+vL+fPn0/T5vz58xQvXjzDPgIDAwkMDLxlv7+/f479cuZk3+7ALcb33//CJ59gOnEC/xkz4IZLr85yi/HlMG8fo8bn+bx9jBpf9vrMjiwFpLJly2brILlt7969REZGAhAQEEC9evVYv369/UyUxWJh/fr1REVFGVmmGCF/fpgwAZ58Et58E55+GkqUMLoqERFxMy6bpO0qiYmJHD161P76xIkT7N27l0KFClGmTBlGjhzJ2bNn+eSTTwCYNm0a5cuXp1q1aly9epWPPvqIDRs2sGbNGnsfQ4YM4emnn6Z+/fo0bNiQadOmcfnyZftdbZLH9OgBM2bA9u3wn//AvHlGVyQiIm7G7QLSrl27uO++++yvhwwZAsDTTz/NvHnziImJ4dSpU/b3r127xtChQzl79izBwcHUrFmTdevWpenj8ccf548//mDUqFHExsZSu3ZtVq9eTURERO4NTNyHyWS77b9RI5g/H154ARo2NLoqERFxI24XkFq0aEFm88bn3fSv/eHDhzN8+PDb9hsVFaVLavKvhg1tl9fmz4dBg+CHH1x227+IiHg+px41IuLRxo2DkBDbpbaFC42uRkRE3IgCkuRdkZG2OUgAw4dDYqKx9YiIiNtQQJK87cUXoXx5OHfOdnebiIgICkiS1wUFwZQptu1Jk+DkSUPLERER96CAJNKpE7RsCcnJ8NJLRlcjIiJuQAFJxGSCadPAxwe++AI2bTK6IhERMZgCkghAjRrQt69te9AgyMazA0VExHsoIImkGjsWwsNh3z6YM8foakRExEAKSCKpihSBMWNs2//9L/z9t7H1iIiIYRSQRG7Urx9UrQpxcfD660ZXIyIiBlFAErmRvz+8/bZt+5134MgRY+sRERFDKCCJ3KxtW+jQAa5fh38eliwiInmLApJIeqZMsZ1NWrkSVq0yuhoREcllCkgi6alUCQYOtG2/+CKYzcbWIyIiuUoBSSQjr74KRYva5iG9957R1YiISC5SQBLJSFgYvPWWbXv0aPjjD0PLERGR3KOAJJKZ3r2hTh2Ij7edURIRkTxBAUkkM76+MH26bXv2bNsq2yIi4vUUkERup1kz6NoVLBYYPBisVqMrEhGRHKaAJOKIiRMhKAiio2HpUqOrERGRHKaAJOKIsmVh+HDb9rBhcOWKsfWIiEiOUkAScdTw4VCqFJw8CVOnGl2NiIjkIAUkEUflzw8TJti2x42Ds2eNrUdERHKMApJIVnTvDvfcA5cvw8iRRlcjIiI5RAFJJCtMpn9v+1+wALZvN7YeERHJEQpIIllVv75tAUmAQYNst/+LiIhXUUASyY633oKQENi5E9PChUZXIyIiLqaAJJIdxYvDK68A4Pvf/+Kr2/5FRLyKApJIdg0eDBUqYIqJodKXXxpdjYiIuJACkkh2BQbClCkAVPjqKzh+3OCCRETEVRSQRJzx0ENY7r8fX7MZ32HDjK5GRERcRAFJxBkmEylTp2Lx9cXn22/h22+NrkhERFxAAUnEWVWrcqxjR9v2oEFw9aqx9YiIiNMUkERc4NfHH8dasqRtHtLEiUaXIyIiTlJAEnGB6/nykZIajMaN04RtEREPp4Ak4iLWLl2gZUvbJbbBg40uR0REnKCAJOIqJhPMmAF+fvDNN5qwLSLiwRSQRFypalUYMsS2PXAgaIVtERGPpIAk4mqvvgolS8KJE5qwLSLioRSQRFwtJASmTrVtjx+vCdsiIh7I7QLS5s2b6dixIyVKlMBkMrF8+fJM2y9dupTWrVtTtGhRQkNDady4Md99912aNqNHj8ZkMqX5qVKlSk4OQ/K6xx7ThG0REQ/mdgHp8uXL1KpVi/fee8+h9ps3b6Z169asXLmS3bt3c99999GxY0f27NmTpl21atWIiYmx/2zZsiUnyhex0YRtERGP5md0ATdr37497du3d7j9tGnT0rx+6623+Oqrr/jmm2+oU6eOfb+fnx/Fixd3WZ0it5U6YXviRNuE7fvvh3z5jK5KREQc4HYByVkWi4VLly5RqFChNPt/++03SpQoQVBQEI0bN2bcuHGUKVMmw36Sk5NJTk62v05ISADAbDZjNptdWnNqf67u113k6fG9/DJ+n32G6cQJUsaNw/Lqq7lcnWvk6T9DL+Dt4wPvH6PG53zfWWWyWq1WF9fiMiaTiWXLltGpUyeHPzNx4kTGjx/P4cOHKVasGACrVq0iMTGRypUrExMTw5gxYzh79iwHDx6kQIEC6fYzevRoxowZc8v+hQsXEhwcnL0BSZ5UYssWGkyeTEpAABveeYcknckUEck1SUlJ9OjRg/j4eEJDQx3+nFcFpIULF9KnTx+++uorWrVqlWG7v//+m7JlyzJ16lSeffbZdNukdwapdOnSxMXFZekLdoTZbGbt2rW0bt0af39/l/btDvL8+KxWfNu3x2fDBiwPPkjKsmW5X6ST8vyfoYfz9vGB949R48u+hIQEihQpkuWA5DWX2D7//HP+7//+jyVLlmQajgDCw8OpVKkSR48ezbBNYGAggYGBt+z39/fPsV/OnOzbHeTp8c2YATVr4rNiBT7ffQcdOuRucS6Sp/8MvYC3jw+8f4waX/b6zA63u4stOxYtWkTv3r1ZtGgRDz744G3bJyYmcuzYMSIjI3OhOhG0wraIiIdxu4CUmJjI3r172bt3LwAnTpxg7969nDp1CoCRI0fSs2dPe/uFCxH8WggAACAASURBVBfSs2dPpkyZQqNGjYiNjSU2Npb4+Hh7m2HDhrFp0yZOnjzJDz/8QOfOnfH19aV79+65OzjJ27TCtoiIx3C7gLRr1y7q1Kljv0V/yJAh1KlTh1GjRgEQExNjD0sAH374IdevX6d///5ERkbafwYNGmRvc+bMGbp3707lypXp2rUrhQsXZvv27RQtWjR3Byd5240rbI8bpxW2RUTcmNvNQWrRogWZzRufN29emtfR0dG37fPzzz93sioRF3nsMfjwQ1i/3rbC9tdfG12RiIikw+3OIIl4tdQVtv39bStsf/ON0RWJeL49e/B59VUK/fyz0ZWIF1FAEsltVarAiy/atgcN0oRtkexISoK5c6FRI6hbF98JE2j01ltw/rzRlYmXUEASMYImbItkzy+/2P5hUaIEPPMM7NwJ/v5YixUj4PJlfEeMMLpCyY7ffqPBhAlwwxxjoykgiRghJATeftu2rQnbIplLToaFC6F5c6hWDd55B+LjoXx5GD8ezpwhZflyrCYTPgsXwsaNRlcsWWG14hsVRYlt2/BNXQ7FDSggiRilSxfbA2yTk23/IhaRtH77DV56CUqVgieegO+/B19f6NwZVq+Go0dhxAgoVgxr/fqcbNfO9rl+/Wz/X4lnWLAAn40bSQkIIGXCBKOrsVNAEjHKjRO2v/1WE7ZFAMxm+OILaN0aKlWCyZMhLs4WksaMgd9/h6VLoW1b8En7V9gvTzyBNSICjhyBSZMMGoBkSVycfRHdw926QYUKBhf0LwUkESNVqfLvCtuasC152e+/wyuvQJkytuUw1q2z/SPigQdsy2GcOAGjRtnm7mXgekgIKalz+t54A44dy6XiJduGDoU//8RaowbHHnrI6GrSUEASMdorr9j+dXziBLjR6WWRHJeSYjtz+uCDtvlEb74JsbEQEQH/+Y9tbt6KFdCxI/g5tmyftVu3fy9dR0WB+z6PXdatg08+AZOJlJkzsTr4Z5xbFJBEjHbjCtvjx2vCtni/c+fg9ddtoeihh2DlSluQuf9+WLIETp+2haVy5bLet8kE778PAQG2eUpffOHy8sUFrlyB55+3bffvj7VhQ2PrSYcCkog76NIFWrXShG3xXhYLrFkDjzxiu4w2apQtCBUuDMOGwa+/2s4odOlim5fnjEqVYORI2/agQZCQ4Hz94lqpl0BLlrSFYTekgCTiDkwmePddTdgW73Phgu3SccWKtonVy5bZLq01awaffQZnztgmVFes6Nrjvvwy3HknxMTYwpi4jwMH/l3/bcYMCA01tp4MKCCJuAtN2BZvYbVCdDR062abX/fyy7ZLx2FhMGAAHDwImzdDjx4QFJQzNQQFwXvv2bbffRd++ilnjiNZY7HAc8/B9evQqZPtx00pIIm4E03YFk/2118wbRpUrQr33QeLF9tu22/YED7+2Db36J13bIs95oY2bWwhzWKxzXdJScmd40rGPvgAtm+HAgVswdWNKSCJuBNN2BZPY7XCtm38f3t3HhdV1f8B/DMMiyIiKsrigqiouYCohWQlCYpmpmalZaaWlCapuZXmgtmT5lb6yzJN05YnHyuXcqkIhVLJBcGlRzENIxfQNGRREZjz++M8MzBsIsvce2c+79drXl7vvXPnfLnD8J17vvccjBwp60lefVWOQ1SnDvDSS/LKzYEDwOjRgLOz5du3bJnswjl0CPjoI8u/PhW6eLGwNuztt+WXQRVjgkSkNizYJi3IzJR3i3XuDNx/v7xd+9YtICAA+PBD+cdw1SogMFDZdnp5FRYBz5wphxEgZUyYIN83QUFytHOVY4JEpDYs2CY1S0iQNSTe3sD48cCxY7LeZ9Qo2XWSmCi7s9RUeDtuHNC1q5y/bcoUpVtjm779FvjmGzme1erVcsoYlWOCRKRGLNgmNcnJAdauBe69F+jWDVizRq675x5Zc3TxIvDJJ/LKgE6ndGtL0utl95qdnZz09qeflG6RbcnKksk0IBNUf39l21NBTJCI1IoF26S048flaNTe3sCYMcDhw3IAxqefBuLigN9+kwl8/fpKt/TOunYFXn5ZLr/8suwOJMuYNUsO5+Drq6khF5ggEamViwvw7rtyeeFCzitFlnHrFvDZZ8ADD8hv+itXyrqRVq3k2DXnz8urMA89pM6rReV56y3A0xP4/ffCcXioZh06VHi32qpVyhTqVxITJCI1GzKksGB70iSlW0PWLDlZdn80aQI89xywb5/smhoyRI6Affo0MG0a0KiR0i2tvHr1ZJcgIO+iOnNG2fZYu7w8ICJC3uk4fLgcdkFDmCARqRkLtqkm3b4NbNoE9Ool696WLZNjGTVrJudKS02Vc5n17i3rd6zBU0/JeHJzZV0MJ7OtOe+9Bxw9CjRoUDh8iYZYyTueyIq1a1d4582ECSzYpqpLSZG3vDdrBgwdCuzZI5PxRx+ViXhKiqwb8fZWuqXVT6eT3YZOTvLK2KZNSrfIOqWkAHPnyuUlS4DGjZVtTyUwQSLSAmPB9rlzLNimStEVFED37bdAv36ynmjBAjlPmpcXMHu2fG999x3Qv78mbsGuEj8/mSACsuv6+nVl22NthJBDK9y8CYSEyCEgNMhe6QYQUQXUqSMLtp98UhZsjxgh/8gRFZWZCVy4YP44fx76v/5C7/37YX/tWuG+vXvL8YoGDJBduLbmtdfkZLmnT8svICqf9kJTNm4EfvhBXqX76CPtFfP/DxMkIq0YMkT+UYuOlrdWb9+udIvIUgoKgPT0kslPkSQIFy4A2dmlPt0OQG0Awt0duuefl4WzrVtbNATVcXKSI4GHhcl/R46UYzxR1Vy7VnhDyRtvAG3aKNueKmCCRKQVxoLtTp2AHTtkd8iAAUq3iqrqxo3Sk52ij0uXKj7RqqurvBOtaVP5b5MmKPD0xMHLl9Ft+nQ4uLjUbDxaEhoKPPOMHLZg7Fg5Z5y1dy/WtOnTZddt+/byKp2GMUEi0pK2bWXB9sKFsmA7LAyoXVvpVlFpDAbg77/Lv+Jz4QKQkVGx49nZyTF8/pf0FE+CTI9SEiBDXh4u79wpr5qQuaVL5ReOhAQ5h1xkpNIt0q64ODniOiC71hwdlW1PFTFBItKaWbOAzz+XRbULFwLz5indItuTmyun1yjtao8xAbp4UY4DUxHOzqUnO0WTIA8POY8VVS9PTzkm0vjxsktoyBBZuE53JzcXeOklufzii3KgUY3jbxuR1hQt2H7nHTmoHwu2q4cQsoaivO6uCxfklaGKaty47Ks9xke9epotZLUKL70ErF8vR32ePBn48kulW6Q9CxbIwUY9Pa3mTlsmSERaVLRge8IEWbDNP7CVk5kJuylTELp9O+wzMio+R5eTU9lXe4wPLy/NdzPYBL1eToNx773yDqzRozU36rOiTp6UCRIALF8OuLkp255qwgSJSIuKFmzv3CkLth97TOlWac/Ro8ATT0B/5gzMKncaNiz7ao8xCWrQgEmpNenSBXjlFfkHfvx4OVFvrVpKt0r9DAZ5Be72bTmG1pNPKt2iasMEiUirihZsT5woryixYLtihADWrZMFubduQTRrhgMjRqDriBFw8PHhz9FWvfkm8NVXco62hQuBqCilW6R+69YBv/wi6+hWrrSqLw0cSZtIy2bNktNFGAu26c5ycmQXypgxsjvtkUeQf/Ag0u+7T9ZyMTmyXa6uhZPZLlggB5GksqWlyQmMATl3n4+Psu2pZkyQiLSsTp3CSSDfeQc4e1bZ9qjdqVNAUBCwYYO8bf7tt2X3ZMOGSreM1OKJJ4C+fWWX0csvczLb8rz6qhymoksXWQtpZZggEWmdsWA7N1d+SPEDvXQbN8oi3N9+k3faxMQAM2ZYzyz1VD10OuD992X9UUyMfN9QSbt2yZ+NnR2wZo1VDkHBTwYirTMWbDs4FBZsU6HcXHkl4Omn5VQcDz8MJCbKSTSJStOqlRwTCSi8SkKFcnLkZLSAnFakSxdl21NDmCARWQNjwTYgC7Zv3lS2PWqRkgL06CFHSAbkH73oaHkFiag806bJ36v09MJkiaSoKODPP4Hmza16oFomSETWggXb5r79Vn6zTUiQNUY7dwJvvcW5tqhijJPZAjLBPnhQ2faoRWKiHKgWkD8fK57bjwkSkbUwjrAN2HbBdl6e/PY/cKDsGuneXX6o9+undMtIa3r1Ap59Vtb1jR0L5Ocr3SJlFRTIaUQKCoCnnpLjHlkxJkhE1uTxx227YPvCBVljtGSJ/P+rr8oJNJs1U7ZdpF1LlsiRoRMTC68o2ar33wcOH5ZT4yxfrnRrapzqEqSff/4ZAwYMgLe3N3Q6HbZu3XrH58TGxqJLly5wcnJC69atsX79+hL7rFy5Ei1atECtWrUQFBSEg7xcStbIlgu2o6OBzp2BffvkeDbffCOHQOBUH1QVHh6FXdazZslJiG1RamphLdaiRTZRx6e6BCknJwcBAQFYuXJlhfZPSUlB//798fDDDyMpKQmTJk3CmDFj8MMPP5j2+c9//oPJkydj7ty5OHLkCAICAhAeHo7Lly/XVBhEymnbFpg6VS7bQsF2QYEsGg0Pl5PIBgYCR47Iq2lE1SEiQo6flZUlr0raGiHk9Cs5OfKmhzFjlG6RRaguQerXrx/eeustDB48uEL7r1q1Cr6+vli6dCnuueceREZG4oknnsC7xloMAMuWLUNERARGjx6N9u3bY9WqVXB2dsa6detqKgwiZb3xhm0UbF++LAf1mzdPfoi/+CKwf7+8TZuoutjZycls7eyATZuA779XukWW9c03ckJsBwdg9WqbGTtM8yM7xcfHIywszGxdeHg4Jk2aBAC4ffs2EhISMGPGDNN2Ozs7hIWFIT4+vszj5ubmIjc31/T/zMxMAEBeXh7y8vKqMwTT8ar7uGrB+BTg6Ajd4sWwHzYM4p13kD9sGNC6daUPp8YYdXv3Qv/ss9BdvAjh7IyClSshhg+XG++ynWqMrzpZe3yABWLs0AF2r7wC/fLlEOPHIz8x0aLT0ih2Dq9fh/2ECdABKJg2DQY/v7v+/aqImoyvssfUfIKUlpYGDw8Ps3UeHh7IzMzEzZs38c8//6CgoKDUfU6dOlXmcRcsWIB5pYzv8OOPP8LZ2bl6Gl9MdHR0jRxXLRifhTk5IbhzZzROSsLVESNwYNasKk8kqYoYhUDrLVtwz+efQ2cwIKtpUxx67TVk1a8v666qQBXx1SBrjw+o2Rjtu3dHr88/R+0//sAfY8bglDEhtyBLn0P/Vavge+kSsr29sadzZxiq+Dt2JzUR340bNyr1PM0nSDVlxowZmDx5sun/mZmZaNasGfr06QNXV9dqfa28vDxER0ejd+/ecHBwqNZjqwHjU5CfH0RgIDwTEtDfYIAYMKBSh1FNjP/8A/3zz8Nuxw4AgOHpp1Fr5Uo8WMWxWFQTXw2x9vgAy8Wo0+mAYcPQZutWtJw9G2jXrsZeqyglzqEuPh72/+tOrLVhA/r27Fljr1WT8Rl7gO6W5hMkT09PpKenm61LT0+Hq6srateuDb1eD71eX+o+nuVU4Ts5OcHJyanEegcHhxp7c9bksdWA8SmgQwdZsL1gAewnT5b1OlW4AqpojIcOybFXzp2Tg/itWAG7iAjYVfGqWFGqPIfVyNrjAywQ41NPAZ9+Ct3OnXCYOFHO11aN78E7sdg5NE7WCwCjR8O+WClLTamJ+Cp7PM1XWgUHByMmJsZsXXR0NIKDgwEAjo6O6Nq1q9k+BoMBMTExpn2IrJqxYPvPP7VZsC0EsHIl8MADMjlq2VIWYr/4okX/MBEBMJ/Mds8e4IsvlG5RzVi8WE7s7O4ul22Q6hKk7OxsJCUlISkpCYC8jT8pKQmpqakAZNfXc889Z9p/7Nix+OOPPzB9+nScOnUKH3zwATZt2oRXi9yKOXnyZKxZswYbNmzAyZMnMW7cOOTk5GD06NGWDY5ICUVH2F60CDhzRtn23I2sLOCZZ4DISPmNdvBgeQu/lU6OSRrh6wvMni2Xp0wB/vlH2fZUt99/B+bPl8vvvSen6rFBqkuQDh8+jMDAQAQGBgKQyU1gYCDmzJkDALh06ZIpWQIAX19f7NixA9HR0QgICMDSpUvx8ccfIzw83LTP0KFDsWTJEsyZMwedO3dGUlISvv/++xKF20RW6/HHgT59tDXC9vHjQLduwMaNgL29HPTxm2/kKL5ESps6FbjnHjnUxMyZSrem+hinVcnNlZ8ZzzyjdIsUo7oapJCQEIhyPrxLGyU7JCQEiYmJ5R43MjISkZGRVW0ekTYZR9ju2BHYtUtO5DpwoNKtKtv69bL+4eZNoGlTOfYMu8RJTRwd5SS2ISHARx8Bo0bJwSS17tNPgd275RAGH35o093YqruCREQ1pE0b8xG2K3nra426cQN44QVg9GiZHIWHyzmwmByRGvXsCTz3nPVMZnvliuwyBIC5c2W9nw1jgkRkS9RcsH36NNC9O7BunRypd/58Oa6Ru7vSLSMq2+LFQP36QFKSLN7WsilTgKtXAX9/oMgwN7aKCRKRLalTRxZdAsA776inYHvTJqBrV1l35OEhJ56dNctmpjQgDWvcWP4uAbJw+/x5ZdtTWT/9BHz2mexSW71aTiti4/jpQ2RrBg+WxZe3bytfsJ2bC7zyCjB0KJCdDTz0kOxS69VLuTYR3a0XXpDdwNnZwP+mudKUmzdlFyEgJ6W1hlqqasAEicjWGAu2HRwKC7aVcO4c8OCDhd0SM2bIQfe8vJRpD1FlGSez1evlnZY1PB1HtZs/Hzh7FmjSBPjXv5RujWowQSKyRW3aANOmyWUlCra3b5djGR06JOs3tm8H3n5b3s5PpEX+/oVXjyIj1XkTRGmOHy8cCPL994FqnkpLy5ggEdmqmTMtX7Cdnw+8/jowYIAcXO+++2SXWv/+lnl9opoUFSWHpUhJ0caVGINBjkifnw8MGiQfZMIEichWWbpg++JFWVtkLGidMAH45RfAx6dmX5fIUlxcgBUr5PLixcDJk8q2505WrQJ+/RWoW1d2u5MZJkhEtmzwYDnWUE0XbMfEAIGBMiGqWxf46itg+XI52B6RNRk0CHj0USAvDxg3Tr2j1l+4IOv+ANm93bSpsu1RISZIRLZMp5PfeGuqYNtgkAWgvXvLKRn8/YGEBOCJJ6r3dYjUwngTRO3aQFycvHVejSZMADIz5R1r48Yp3RpVYoJEZOtqqmD7yhWgXz9gzhz5LXrMGHk538+veo5PpFYtWsiRqAE5+OK1a4o2p4Rt24DNm+VNEatXy7vvqAQmSERU/QXb+/fLLrUff5TfpNevB9askctEtuDVV4H27YG//y7sylKDrCx5lx0gpx7y91e2PSrGBImIqq9gWwhg6VI5R9WFC0DbtsDBg8DIkdXXViItME5mC8irNPv3K9seo1mz5GjfLVvKq7tUJiZIRCRVtWA7IwN4/HH5rTQ/Hxg2TI5z1LFjzbSXSO0eekhOvAzIOh+lJ7M9eLDwbrVVq3hF9w6YIBGRVJWC7YQEOfDj1q3ym/MHHwD//re8Y43Ili1aBDRoABw7VjgEgBLy8uSYR0IAzz4rb5ygcjFBIqJCd1uwLYT8Jnr//XJwPF9f2ZUwbpxMuIhsnbu7TJIA2aX111/KtOO994CjR2WytmyZMm3QGCZIRGRu5kygeXNZsL1gQdn7ZWfLb6LjxsluuYED5ZWkrl0t11YiLRg9GujRA8jJkV88LC0lpfCuuqVLgUaNLN8GDWKCRETm6tQB3n1XLi9aVHrB9m+/AffeK7vR9HpgyRJgyxY5rxoRmbOzkwXb9vby92T7dsu9thDyS8zNm8DDD/OGibvABImISiqvYPuzz+QcaqdOydm/4+LkWC/sUiMqW6dO8tZ/wLKT2W7cCPzwA+DkJLvD+XtaYUyQiKgk42jAjo7Arl3Qffst7HJzoR87FnjuOfnh3ru3nGi2Rw+lW0ukDXPnFnZfz59f86937Vphl96sWbLGkCqMCRIRlc7PT96yD0A/ZQoefP112K1bJ5OnefPknW6sZSCquDp1Cm+zX7JEdlXXpOnT5Yj27dvLZborTJCIqGz/K9jWpabCLSUFolEjOTr2nDmcnoCoMh57TD7y82t2Mtu4OGDtWrm8ejUnhq4EJkhEVLY6dYAPPoBwdMTfHTog/+BBICxM6VYRaduKFYCzM/DLL8CGDdV//Nxc4KWX5PJLL7EbvJKYIBFR+fr3R35aGvb961+yKJuIqsbHB4iKkstTpwJXr1bv8RcsAJKTAU/P6plb0UYxQSKiO3NxUboFRNZl0iQ5Dc/Vq8Brr1XfcU+eBN5+Wy6vWAG4uVXfsW0MEyQiIiJLc3AonMx27Vpg376qH9NgkF1qeXlA//7AE09U/Zg2jAkSERGREh54AHjhBbk8dqxMbKpi3TpZ11SnDrByJcc8qiImSEREREp55x2gYUPgxAk5X1plpaUVzqM4f76sc6IqYYJERESklIYNgcWL5XJUFJCaWrnjvPoqkJEBdOkCvPJKtTXPljFBIiIiUtLIkcCDD8oR6idMuPvn79olpxSxswPWrJFzvlGVMUEiIiJSUtHJbLdtk4+KysmRA04C8s64Ll1qpo02iAkSERGR0jp0kJM+A/IqUk5OxZ4XFSXndvPxkVMAUbVhgkRERKQGs2fLRCc1FXjzzTvvn5gIvPuuXP7gA45XVs2YIBEREalBnTrA++/L5WXLgOPHy963oACIiJD/PvUU8MgjlmmjDWGCREREpBaPPgoMHlw4ma3BUPp+//d/QEICUK8esHy5ZdtoI5ggERERqcny5fJq0r59wPr1JbenpgKzZsnlRYvknGtU7ZggERERqUmzZoUF19OmAX//XbhNCGD8eFnE/cADwJgxyrTRBjBBIiIiUpsJEwB/f+DaNWD6dNNq3ebNwPbtci631avlEAFUI/iTJSIiUpuik9l+8gl0e/fCPjsb+smT5brXXwfuuUe59tkAJkhERERqdP/98k41APrx49Fx/XroLl0C2rQBZs5UuHHWT7UJ0sqVK9GiRQvUqlULQUFBOHjwYJn7hoSEQKfTlXj079/ftM+oUaNKbO/bt68lQiEiIqqchQsBd3foTp6Ez08/yXUffQTUqqVsu2yAKhOk//znP5g8eTLmzp2LI0eOICAgAOHh4bh8+XKp+2/evBmXLl0yPU6cOAG9Xo8nn3zSbL++ffua7ffll19aIhwiIqLKadAAWLrU9F/DqFFASIhizbElqkyQli1bhoiICIwePRrt27fHqlWr4OzsjHXr1pW6f4MGDeDp6Wl6REdHw9nZuUSC5OTkZLZf/fr1LREOERFR5Y0YAcOwYfjHzw8FCxYo3Rqbobopf2/fvo2EhATMmDHDtM7Ozg5hYWGIj4+v0DHWrl2LYcOGoU6dOmbrY2Nj0bhxY9SvXx+9evXCW2+9hYYNG5Z6jNzcXOTm5pr+n5mZCQDIy8tDXl7e3YZVLuPxqvu4asH4tM/aY2R82mftMeatXYufo6PR29UVsMIYa/L8VfaYOiGEqOa2VMnFixfRpEkT7N+/H8HBwab106dPR1xcHA4cOFDu8w8ePIigoCAcOHAA9913n2n9xo0b4ezsDF9fX5w9exYzZ86Ei4sL4uPjodfrSxwnKioK80qZ+O/f//43nJ2dqxAhERERWcqNGzfwzDPP4Pr163B1da3w81R3Bamq1q5di06dOpklRwAwbNgw03KnTp3g7++PVq1aITY2FqGhoSWOM2PGDEw23k4JeQWpWbNm6NOnz139gCsiLy8P0dHR6N27NxwcHKr12GrA+LTP2mNkfNpn7TEyvsoz9gDdLdUlSO7u7tDr9UhPTzdbn56eDs87DKeek5ODjRs34s0KzILcsmVLuLu748yZM6UmSE5OTnByciqx3sHBocbenDV5bDVgfNpn7TEyPu2z9hgZX+WOWRmqK9J2dHRE165dERMTY1pnMBgQExNj1uVWmq+++gq5ubl49tln7/g658+fx9WrV+Hl5VXlNhMREZF1UV2CBACTJ0/GmjVrsGHDBpw8eRLjxo1DTk4ORo8eDQB47rnnzIq4jdauXYtBgwaVKLzOzs7GtGnT8Ouvv+LcuXOIiYnBwIED0bp1a4SHh1skJiIiItIO1XWxAcDQoUNx5coVzJkzB2lpaejcuTO+//57eHh4AABSU1NhV2z+meTkZOzduxc//vhjiePp9XocO3YMGzZsQEZGBry9vdGnTx/Mnz+/1G40IiIism2qTJAAIDIyEpGRkaVui42NLbGubdu2KOuGvNq1a+OHH36ozuYRERGRFVNlFxsRERGRkpggERERERXDBImIiIioGCZIRERERMUwQSIiIiIqhgkSERERUTFMkIiIiIiKUe04SGpjHGOpspPelScvLw83btxAZmamVc6xw/i0z9pjZHzaZ+0xMr7KM/7dLmusxLIwQaqgrKwsAECzZs0UbgkRERHdraysLNSrV6/C++vE3aZUNspgMODixYuoW7cudDpdtR47MzMTzZo1w19//QVXV9dqPbYaMD7ts/YYGZ/2WXuMjK/yhBDIysqCt7d3iWnKysMrSBVkZ2eHpk2b1uhruLq6WuUb34jxaZ+1x8j4tM/aY2R8lXM3V46MWKRNREREVAwTJCIiIqJi9FFRUVFKN4IAvV6PkJAQ2NtbZ68n49M+a4+R8WmftcfI+CyLRdpERERExbCLjYiIiKgYJkhERERExTBBIiIiIiqGCRIRERFRMUyQLCQqKgo6nc7s0a5dO9P2W7duYfz48WjYsCFcXFwwZMgQpKenK9ji8v38888YMGAAvL29odPpsHXrVrPtQgjMmTMHXl5eqF27NsLCwvD777+b7XPt2jUMHz4crq6ucHNzwwsvvIDs7GxLhlGuO8U4atSoEue0b9++ZvuoOcYFCxbg3nvvRd26ddG4cWMMGjQIycnJZvtU5H2ZmpqK/v37w9nZGY0blekwVQAADf5JREFUN8a0adOQn59vyVBKVZH4QkJCSpzDsWPHmu2j1vg+/PBD+Pv7mwbWCw4Oxq5du0zbtXzujO4Uo5bPX2kWLlwInU6HSZMmmdZZw3k0Ki0+VZ9DQRYxd+5c0aFDB3Hp0iXT48qVK6btY8eOFc2aNRMxMTHi8OHDonv37uL+++9XsMXl27lzp3jjjTfE5s2bBQCxZcsWs+0LFy4U9erVE1u3bhVHjx4Vjz32mPD19RU3b9407dO3b18REBAgfv31V/HLL7+I1q1bi6efftrSoZTpTjGOHDlS9O3b1+ycXrt2zWwfNccYHh4uPvnkE3HixAmRlJQkHnnkEdG8eXORnZ1t2udO78v8/HzRsWNHERYWJhITE8XOnTuFu7u7mDFjhhIhmalIfD179hQRERFm5/D69eum7WqO79tvvxU7duwQp0+fFsnJyWLmzJnCwcFBnDhxQgih7XNndKcYtXz+ijt48KBo0aKF8Pf3FxMnTjStt4bzKETZ8an5HDJBspC5c+eKgICAUrdlZGQIBwcH8dVXX5nWnTx5UgAQ8fHxlmpipRVPHgwGg/D09BSLFy82rcvIyBBOTk7iyy+/FEII8d///lcAEIcOHTLts2vXLqHT6cSFCxcs1/gKKitBGjhwYJnP0VqMly9fFgBEXFycEKJi78udO3cKOzs7kZaWZtrnww8/FK6uriI3N9eyAdxB8fiEkB/ORT+si9NSfEIIUb9+ffHxxx9b3bkryhijENZz/rKysoSfn5+Ijo42i8lazmNZ8Qmh7nPILjYL+v333+Ht7Y2WLVti+PDhSE1NBQAkJCQgLy8PYWFhpn3btWuH5s2bIz4+XqnmVlpKSgrS0tLM4qlXrx6CgoJM8cTHx8PNzQ3dunUz7RMWFgY7OzscOHDA4m2urNjYWDRu3Bht27bFuHHjcPXqVdM2rcV4/fp1AECDBg0AVOx9GR8fj06dOsHDw8O0T3h4ODIzM/Hbb79ZsPV3Vjw+oy+++ALu7u7o2LEjZsyYgRs3bpi2aSW+goICbNy4ETk5OQgODra6cweUjNHIGs7f+PHj0b9/f7PzBVjP72BZ8Rmp9RyqY7hKGxAUFIT169ejbdu2uHTpEubNm4cHH3wQJ06cQFpaGhwdHeHm5mb2HA8PD6SlpSnU4soztrnoG9r4f+O2tLQ0NG7c2Gy7vb09GjRooJmY+/bti8cffxy+vr44e/YsZs6ciX79+iE+Ph56vV5TMRoMBkyaNAk9evRAx44dAaBC78u0tLRSz7Nxm1qUFh8APPPMM/Dx8YG3tzeOHTuG1157DcnJydi8eTMA9cd3/PhxBAcH49atW3BxccGWLVvQvn17JCUlWc25KytGQPvnDwA2btyII0eO4NChQyW2WcPvYHnxAeo+h0yQLKRfv36mZX9/fwQFBcHHxwebNm1C7dq1FWwZVdawYcNMy506dYK/vz9atWqF2NhYhIaGKtiyuzd+/HicOHECe/fuVbopNaKs+F588UXTcqdOneDl5YXQ0FCcPXsWrVq1snQz71rbtm2RlJSE69ev4+uvv8bIkSMRFxendLOqVVkxtm/fXvPn76+//sLEiRMRHR2NWrVqKd2caleR+NR8DtnFphA3Nze0adMGZ86cgaenJ27fvo2MjAyzfdLT0+Hp6alQCyvP2Obid1oUjcfT0xOXL182256fn49r165pMmYAaNmyJdzd3XHmzBkA2okxMjIS27dvx549e9C0aVPT+oq8Lz09PUs9z8ZtalBWfKUJCgoCALNzqOb4HB0d0bp1a3Tt2hULFixAQEAAli9fbjXnDig7xtJo7fwlJCTg8uXL6NKlC+zt7WFvb4+4uDisWLEC9vb28PDw0PR5vFN8BQUFJZ6jpnPIBEkh2dnZOHv2LLy8vNC1a1c4ODggJibGtD05ORmpqalmfe1a4evrC09PT7N4MjMzceDAAVM8wcHByMjIQEJCgmmf3bt3w2AwmH5BtOb8+fO4evUqvLy8AKg/RiEEIiMjsWXLFuzevRu+vr5m2yvyvgwODsbx48fNEsHo6Gi4urqaukGUcqf4SpOUlAQAZudQrfGVxmAwIDc3V/PnrjzGGEujtfMXGhqK48ePIykpyfTo1q0bhg8fblrW8nm8U3x6vb7Ec1R1Dmu0BJxMpkyZImJjY0VKSorYt2+fCAsLE+7u7uLy5ctCCHkrZ/PmzcXu3bvF4cOHRXBwsAgODla41WXLysoSiYmJIjExUQAQy5YtE4mJieLPP/8UQsjb/N3c3MS2bdvEsWPHxMCBA0u9zT8wMFAcOHBA7N27V/j5+anmFnghyo8xKytLTJ06VcTHx4uUlBTx008/iS5dugg/Pz9x69Yt0zHUHOO4ceNEvXr1RGxsrNkttjdu3DDtc6f3pfEW3D59+oikpCTx/fffi0aNGqniFuM7xXfmzBnx5ptvisOHD4uUlBSxbds20bJlS/HQQw+ZjqHm+F5//XURFxcnUlJSxLFjx8Trr78udDqd+PHHH4UQ2j53RuXFqPXzV5bid3VZw3ksqmh8aj+HTJAsZOjQocLLy0s4OjqKJk2aiKFDh4ozZ86Ytt+8eVO8/PLLon79+sLZ2VkMHjxYXLp0ScEWl2/Pnj0CQInHyJEjhRDyVv/Zs2cLDw8P4eTkJEJDQ0VycrLZMa5evSqefvpp4eLiIlxdXcXo0aNFVlaWAtGUrrwYb9y4Ifr06SMaNWokHBwchI+Pj4iIiDC7FVUIdcdYWmwAxCeffGLapyLvy3Pnzol+/fqJ2rVrC3d3dzFlyhSRl5dn4WhKulN8qamp4qGHHhINGjQQTk5OonXr1mLatGlmY7AIod74nn/+eeHj4yMcHR1Fo0aNRGhoqCk5EkLb586ovBi1fv7KUjxBsobzWFTR+NR+DnVCCFGz16iIiIiItIU1SERERETFMEEiIiIiKoYJEhEREVExTJCIiIiIimGCRERERFQMEyQiIiKiYpggERERERXDBImIVC02NhY6nQ5RUVFKN6Vco0aNgk6nw7lz55RuChFVAyZIRGTTdDodQkJClG4GEakMEyQiIiKiYpggERERERXDBImINGPv3r0ICQlB3bp14ebmhiFDhuDMmTNm++zZswfPP/882rZtCxcXF7i4uKBbt25YvXq12X7G2iYAiIuLg06nMz3Wr19vtu+2bdvQp08fNGzYELVq1UKLFi0wYsQInDhxokQbhRBYsWIF2rVrBycnJ/j4+GDevHkwGAzV+8Mgohqlj1J75SMR2bRz585hw4YNqFWrFubNm4eOHTvi0UcfhbOzM7Zt24Yvv/wSQ4YMQf369QEA48aNQ2JiIoKCghAWFoY2bdrg2LFj+Pzzz5GVlYXw8HDTsd3c3BAXFwcfHx9MmjQJISEhpoenpycAYMqUKZg4cSIyMjIwaNAghIWFwc3NDTExMfD29kb37t0BAFu3bsXRo0dx/vx5fPrppwgNDUWPHj1w6tQpbNu2Dfn5+QgNDbX8D5CIKkcQEanYnj17BAABQKxatcps26pVqwQA8eijj5rW/fHHHyWOkZeXJ3r37i30er34888/zbYBED179iz1tb/77jsBQHTq1En8/fffJY6ZlpZm+v/IkSMFAOHr6ysuXrxoWn/lyhXh5uYm6tatK3JzcyscNxEpi11sRKQJbdq0QUREhNm6iIgI+Pn5YceOHbhy5QoAwNfXt8Rz7e3tMXbsWBQUFGDPnj0Vfs0PPvgAALB8+XI0bNiwxDE9PDxKPGf27Nnw8vIy/d/d3R0DBw5EVlYWkpOTK/zaRKQsJkhEpAk9evSAnZ35R5adnR169OgBIQSOHj0KAMjKysLcuXMREBAAFxcXU13RkCFDAAAXL16s8GsePHgQTk5O6NmzZ4Wf07Vr1xLrmjZtCgDIyMio8HGISFn2SjeAiKgiSrtaU3T99evXcfv2bYSEhODIkSMIDAzEiBEj0LBhQ9jb25tqmXJzcyv8mtevX0eTJk1KJGblcXV1LbHO3l5+1BYUFFT4OESkLCZIRKQJ6enp5a6vV68etm3bhiNHjuCFF17Axx9/bLbfxo0bsWHDhrt6TTc3N6SlpcFgMNxVkkRE2sffeCLShH379pW4Vd5gMGD//v3Q6XQICAjA2bNnAQADBw4s8fxffvml1OPa2dmVeWXnvvvuQ25uLuLi4qrYeiLSGiZIRKQJp0+fxpo1a8zWrVmzBqdPn0b//v3RqFEj+Pj4AJDjJRUVFxdX4rlGDRo0wPnz50vdNn78eADAxIkTce3aNbNt+fn5ZV7VIiLtYxcbEWlCeHg4JkyYgJ07d6JDhw747bff8N1338Hd3R3Lly8HAAwYMAAtWrTAokWLcOLECXTs2BHJycnYvn07Bg8ejK+//rrEcXv16oVNmzZh0KBBCAwMhF6vx2OPPQZ/f3888sgjmDp1KpYsWQI/Pz8MHjwYjRs3xoULFxATE4OpU6di0qRJlv5REJEFMEEiIk3o3r07Zs2ahVmzZmHFihXQ6/UYNGgQFi1ahJYtWwIAXFxcsHv3bkybNg0///wzYmNj0aFDB3zxxRfw8PAoNUEyJle7d+/Gd999B4PBgKZNm8Lf3x8AsHjxYgQHB+P999/H119/jVu3bsHLywu9evVC7969LfcDICKL0gkhhNKNICIiIlIT1iARERERFcMEiYiIiKgYJkhERERExTBBIiIiIiqGCRIRERFRMUyQiIiIiIphgkRERERUDBMkIiIiomKYIBEREREVwwSJiIiIqBgmSERERETFMEEiIiIiKoYJEhEREVEx/w8vP8PYDnDoBAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with fluid.dygraph.guard():\n",
    "    model=MyLeNet() #模型实例化\n",
    "    model.train() #训练模式\n",
    "    opt=fluid.optimizer.SGDOptimizer(learning_rate=train_parameters['learning_strategy']['lr'], parameter_list=model.parameters())#优化器选用SGD随机梯度下降，学习率为0.001.\n",
    "    epochs_num=train_parameters['num_epochs'] #迭代次数\n",
    "    \n",
    "    for pass_num in range(epochs_num):\n",
    "        for batch_id,data in enumerate(train_reader()):\n",
    "            images=np.array([x[0].reshape(1,20,20) for x in data],np.float32)\n",
    "            labels = np.array([x[1] for x in data]).astype('int64')\n",
    "            labels = labels[:, np.newaxis]\n",
    "            image=fluid.dygraph.to_variable(images)\n",
    "            label=fluid.dygraph.to_variable(labels)\n",
    "\n",
    "            predict=model(image) #数据传入model\n",
    "            \n",
    "            loss=fluid.layers.cross_entropy(predict,label)\n",
    "            avg_loss=fluid.layers.mean(loss)#获取loss值\n",
    "            \n",
    "            acc=fluid.layers.accuracy(predict,label)#计算精度\n",
    "            \n",
    "            if batch_id!=0 and batch_id%50==0:\n",
    "                Batch = Batch+50 \n",
    "                Batchs.append(Batch)\n",
    "                all_train_loss.append(avg_loss.numpy()[0])\n",
    "                all_train_accs.append(acc.numpy()[0])\n",
    "                \n",
    "                print(\"train_pass:{},batch_id:{},train_loss:{},train_acc:{}\".format(pass_num,batch_id,avg_loss.numpy(),acc.numpy()))\n",
    "            \n",
    "            avg_loss.backward()       \n",
    "            opt.minimize(avg_loss)    #优化器对象的minimize方法对参数进行更新 \n",
    "            model.clear_gradients()   #model.clear_gradients()来重置梯度\n",
    "    fluid.save_dygraph(model.state_dict(),'MyLeNet')#保存模型\n",
    "\n",
    "draw_train_acc(Batchs,all_train_accs)\n",
    "draw_train_loss(Batchs,all_train_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 4、模型评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.81311274\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#模型评估\n",
    "with fluid.dygraph.guard():\n",
    "    accs = []\n",
    "    model_dict, _ = fluid.load_dygraph('MyLeNet')\n",
    "    model = MyLeNet()\n",
    "    model.load_dict(model_dict) #加载模型参数\n",
    "    model.eval() #训练模式\n",
    "    for batch_id,data in enumerate(eval_reader()):#测试集\n",
    "        images=np.array([x[0].reshape(1,20,20) for x in data],np.float32)\n",
    "        labels = np.array([x[1] for x in data]).astype('int64')\n",
    "        labels = labels[:, np.newaxis]\n",
    "        image=fluid.dygraph.to_variable(images)\n",
    "        label=fluid.dygraph.to_variable(labels)       \n",
    "        predict=model(image)       \n",
    "        acc=fluid.layers.accuracy(predict,label)\n",
    "        accs.append(acc.numpy()[0])\n",
    "        avg_acc = np.mean(accs)\n",
    "    print(avg_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 5、使用模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### **5.1对车牌图像进行预处理**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 对车牌图片进行处理，分割出车牌中的每一个字符并保存\n",
    "license_plate = cv2.imread('work/车牌2.png')\n",
    "gray_plate = cv2.cvtColor(license_plate, cv2.COLOR_RGB2GRAY) \n",
    "ret, binary_plate = cv2.threshold(gray_plate, 175, 255, cv2.THRESH_BINARY) #ret：阈值，binary_plate：根据阈值处理后的图像数据\n",
    "# 按列统计像素分布\n",
    "result = []\n",
    "for col in range(binary_plate.shape[1]):\n",
    "    result.append(0)\n",
    "    for row in range(binary_plate.shape[0]):\n",
    "        result[col] = result[col] + binary_plate[row][col]/255\n",
    "# print(result)\n",
    "#记录车牌中字符的位置\n",
    "character_dict = {}\n",
    "num = 0\n",
    "i = 0\n",
    "while i < len(result):\n",
    "    if result[i] == 0:\n",
    "        i += 1\n",
    "    else:\n",
    "        index = i + 1\n",
    "        while result[index] != 0:\n",
    "            index += 1\n",
    "        character_dict[num] = [i, index-1]\n",
    "        num += 1\n",
    "        i = index\n",
    "# print(character_dict)        \n",
    "#将每个字符填充，并存储\n",
    "characters = []\n",
    "for i in range(8):\n",
    "    if i==2:\n",
    "        continue\n",
    "    padding = (170 - (character_dict[i][1] - character_dict[i][0])) / 2\n",
    "    #将单个字符图像填充为170*170\n",
    "    ndarray = np.pad(binary_plate[:,character_dict[i][0]:character_dict[i][1]], ((0,0), (int(padding), int(padding))), 'constant', constant_values=(0,0))\n",
    "    ndarray = cv2.resize(ndarray, (20,20))\n",
    "    cv2.imwrite('work/' + str(i) + '.png', ndarray)\n",
    "    characters.append(ndarray)\n",
    "    \n",
    "def load_image(path):\n",
    "    img = paddle.dataset.image.load_image(file=path, is_color=False)\n",
    "    img = img.astype('float32')\n",
    "    img = img[np.newaxis, ] / 255.0\n",
    "    return img\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### **5.2 对标签进行转换**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label: {'0': 'gan1', '1': 'P', '2': 'qing', '3': 'shan', '4': 'E', '5': 'su', '6': 'W', '7': 'R', '8': 'U', '9': 'N', '10': 'meng', '11': '9', '12': 'cuan', '13': 'qiong', '14': '7', '15': 'e1', '16': '5', '17': '3', '18': 'Z', '19': 'zhe', '20': 'jin', '21': 'jing', '22': 'D', '23': 'xin', '24': '6', '25': 'G', '26': 'X', '27': '1', '28': '4', '29': 'gui1', '30': 'T', '31': 'S', '32': 'lu', '33': 'ning', '34': 'V', '35': 'ji', '36': 'yu', '37': 'F', '38': 'Q', '39': 'M', '40': 'L', '41': '0', '42': 'C', '43': '8', '44': 'H', '45': 'hei', '46': 'liao', '47': 'Y', '48': 'gui', '49': '2', '50': 'yu1', '51': 'zang', '52': 'yue', '53': 'sx', '54': 'min', '55': 'hu', '56': 'yun', '57': 'xiang', '58': 'B', '59': 'J', '60': 'A', '61': 'jl', '62': 'gan', '63': 'wan', '64': 'K'}\n",
      "{'0': '甘', '1': 'P', '2': '青', '3': '陕', '4': 'E', '5': '苏', '6': 'W', '7': 'R', '8': 'U', '9': 'N', '10': '蒙', '11': '9', '12': '川', '13': '琼', '14': '7', '15': '鄂', '16': '5', '17': '3', '18': 'Z', '19': '浙', '20': '津', '21': '京', '22': 'D', '23': '新', '24': '6', '25': 'G', '26': 'X', '27': '1', '28': '4', '29': '桂', '30': 'T', '31': 'S', '32': '鲁', '33': '宁', '34': 'V', '35': '冀', '36': '豫', '37': 'F', '38': 'Q', '39': 'M', '40': 'L', '41': '0', '42': 'C', '43': '8', '44': 'H', '45': '黑', '46': '辽', '47': 'Y', '48': '贵', '49': '2', '50': '渝', '51': '藏', '52': '粤', '53': '晋', '54': '闽', '55': '沪', '56': '云', '57': '湘', '58': 'B', '59': 'J', '60': 'A', '61': '吉', '62': '赣', '63': '皖', '64': 'K'}\n"
     ]
    }
   ],
   "source": [
    "#将标签进行转换\n",
    "print('Label:',train_parameters['label_dict'])\n",
    "match = {'A':'A','B':'B','C':'C','D':'D','E':'E','F':'F','G':'G','H':'H','I':'I','J':'J','K':'K','L':'L','M':'M','N':'N',\n",
    "        'O':'O','P':'P','Q':'Q','R':'R','S':'S','T':'T','U':'U','V':'V','W':'W','X':'X','Y':'Y','Z':'Z',\n",
    "        'yun':'云','cuan':'川','hei':'黑','zhe':'浙','ning':'宁','jin':'津','gan':'赣','hu':'沪','liao':'辽','jl':'吉','qing':'青','zang':'藏',\n",
    "        'e1':'鄂','meng':'蒙','gan1':'甘','qiong':'琼','shan':'陕','min':'闽','su':'苏','xin':'新','wan':'皖','jing':'京','xiang':'湘','gui':'贵',\n",
    "        'yu1':'渝','yu':'豫','ji':'冀','yue':'粤','gui1':'桂','sx':'晋','lu':'鲁',\n",
    "        '0':'0','1':'1','2':'2','3':'3','4':'4','5':'5','6':'6','7':'7','8':'8','9':'9'}\n",
    "L = 0\n",
    "LABEL ={}\n",
    "for V in train_parameters['label_dict'].values():\n",
    "    LABEL[str(L)] = match[V]\n",
    "    L += 1\n",
    "print(LABEL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### **5.3 使用模型进行预测**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[21, 60, 4, 41, 49, 17, 24]\n",
      "京AE0236"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=832x203 at 0x7FD082681E10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#构建预测动态图过程\n",
    "with fluid.dygraph.guard():\n",
    "    model=MyLeNet()#模型实例化\n",
    "    model_dict,_=fluid.load_dygraph('MyLeNet')\n",
    "    model.load_dict(model_dict)#加载模型参数\n",
    "    model.eval()#评估模式\n",
    "    lab=[]\n",
    "    for i in range(8):\n",
    "        if i==2:\n",
    "            continue\n",
    "        infer_imgs = []\n",
    "        infer_imgs.append(load_image('work/' + str(i) + '.png'))\n",
    "        infer_imgs = np.array(infer_imgs)\n",
    "        infer_imgs = fluid.dygraph.to_variable(infer_imgs)\n",
    "        result=model(infer_imgs)\n",
    "        lab.append(np.argmax(result.numpy()))\n",
    "print(lab)\n",
    "display(Image.open('work/车牌2.png'))\n",
    "for i in range(len(lab)):\n",
    "    print(LABEL[str(lab[i])],end='')\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
